






import math







def      snake_case		(							UpperCAmelCase	:       int   ):
				A	 =      math.loga(math.sqrt(4 * positive_integer + 1   ) / 2 + 1 / 2   )

				return exponent == int(UpperCAmelCase   )







def      snake_case		(							UpperCAmelCase	:       float = 1 / 1_23_45   ):
				A	 =      0
				A	 =      0

				A	 =      3
				while True:
								A	 =      (integer**2 - 1) / 4
								# if candidate is an integer, then there is a partition for k
								if partition_candidate == int(UpperCAmelCase   ):
												A	 =      int(UpperCAmelCase   )
												total_partitions += 1
												if check_partition_perfect(UpperCAmelCase   ):
																perfect_partitions += 1
								if perfect_partitions > 0:
												if perfect_partitions / total_partitions < max_proportion:
																return int(UpperCAmelCase   )
								integer += 1


if __name__ == "__main__":
					print(f'''{solution() = }''')













from collections import deque

from .hash_table import HashTable
class      UpperCamelCase (				snake_case__ ):







		"""simple docstring"""



		def __init__(  self		:       Any						,*_SCREAMING_SNAKE_CASE		:       Optional[int]						,**_SCREAMING_SNAKE_CASE		:       Optional[Any]		)    ->   int:


						'''simple docstring'''
						super().__init__(*_SCREAMING_SNAKE_CASE						,**_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple		)    ->   List[str]:


						'''simple docstring'''
						A	 =      deque([]		) if self.values[key] is None else self.values[key]
						self.values[key].appendleft(_SCREAMING_SNAKE_CASE		)
						A	 =      self.values[key]
		def       A(  self		:       Optional[Any]		)    ->   Union[str, Any]:


						'''simple docstring'''
						return (
						    sum(self.charge_factor - len(_SCREAMING_SNAKE_CASE		) for slot in self.values		)
						    / self.size_table
						    * self.charge_factor
						)







		def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       str=None		)    ->   Union[str, Any]:


						'''simple docstring'''
						if not (
						    len(self.values[key]		) == self.charge_factor and self.values.count(_SCREAMING_SNAKE_CASE		) == 0
						):
										return key
						return super()._collision_resolution(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)





