

from .number_theory.prime_numbers import next_prime





class 			snake_case_     :







			'''simple docstring'''

			def __init__(  self				:       Tuple							,     _UpperCamelCase				:       int							,     _UpperCamelCase				:       int | None = None							,     _UpperCamelCase				:       float | None = None							,     )   ->None:
									snake_case_     =			size_table
									snake_case_     =			[None] * self.size_table
									snake_case_     =			0.75 if lim_charge is None else lim_charge
									snake_case_     =			1 if charge_factor is None else charge_factor
									snake_case_     =			[]
									snake_case_     =			{}







			def        snake_case__(  self				:       Union[str, Any]							)   ->Optional[int]:
									return self._keys







			def        snake_case__(  self				:       Optional[Any]							)   ->Union[str, Any]:
									return sum(1 for slot in self.values if slot is not None							) / (
									    self.size_table * self.charge_factor
									)







			def        snake_case__(  self				:       Dict							,     _UpperCamelCase				:       List[Any]							)   ->List[str]:
									return key % self.size_table







			def        snake_case__(  self				:       int							,     _UpperCamelCase				:       Optional[int]							)   ->List[Any]:
									print(f'''step {step_ord}'''							)
									print(list(range(len(self.values							)							)							)							)
									print(self.values							)







			def        snake_case__(  self				:       str							,     _UpperCamelCase				:       Any							)   ->Optional[int]:
									snake_case_     =			1
									snake_case_     =			values
									for value in values:
															self.insert_data(_UpperCamelCase							)
															self._step_by_step(_UpperCamelCase							)
															i += 1







			def        snake_case__(  self				:       Union[str, Any]							,     _UpperCamelCase				:       Dict							,     _UpperCamelCase				:       Union[str, Any]							)   ->str:
									snake_case_     =			data
									snake_case_     =			data







			def        snake_case__(  self				:       Optional[int]							,     _UpperCamelCase				:       str							,     _UpperCamelCase				:       str=None							)   ->Tuple:
									snake_case_     =			self.hash_function(key + 1							)

									while self.values[new_key] is not None and self.values[new_key] != key:
															if self.values.count(_UpperCamelCase							) > 0:
																					snake_case_     =			self.hash_function(new_key + 1							)
															else:
																					snake_case_     =			None
																					break

									return new_key







			def        snake_case__(  self				:       Union[str, Any]							)   ->List[Any]:
									snake_case_     =			[value for value in self.values if value is not None]
									snake_case_     =			next_prime(self.size_table							,     factor=2							)
									self._keys.clear()
									snake_case_     =			[None] * self.size_table  # hell's pointers D: don't DRY ;/
									for value in survivor_values:
															self.insert_data(_UpperCamelCase							)







			def        snake_case__(  self				:       Dict							,     _UpperCamelCase				:       int							)   ->str:
									snake_case_     =			self.hash_function(_UpperCamelCase							)

									if self.values[key] is None:
															self._set_value(_UpperCamelCase							,     _UpperCamelCase							)

									elif self.values[key] == data:
															pass

									else:
															snake_case_     =			self._collision_resolution(_UpperCamelCase							,     _UpperCamelCase							)
															if collision_resolution is not None:
																					self._set_value(_UpperCamelCase							,     _UpperCamelCase							)
															else:
																					self.rehashing()
																					self.insert_data(_UpperCamelCase							)


def 						__SCREAMING_SNAKE_CASE      (SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ ):
						return (input_a, input_a).count(0 ) % 2


def 						__SCREAMING_SNAKE_CASE      ():
						assert xor_gate(0						,	0 ) == 0
						assert xor_gate(0						,	1 ) == 1
						assert xor_gate(1						,	0 ) == 1
						assert xor_gate(1						,	1 ) == 0


if __name__ == "__main__":
					print(xor_gate(0, 0))
					print(xor_gate(0, 1))