



def 				A				(					_lowerCamelCase = 50_000_000  ):





							'''simple docstring'''




							_lowerCAmelCase     :							Optional[Any]    =    set()
							_lowerCAmelCase     :							Any    =    int((limit - 24) ** (1 / 2)  )

							_lowerCAmelCase     :							Tuple    =    set(range(3				, prime_square_limit + 1				, 2  )  )
							primes.add(2  )
							for p in range(3				, prime_square_limit + 1				, 2  ):
														if p not in primes:
																					continue
														primes.difference_update(set(range(p * p				, prime_square_limit + 1				, _lowerCamelCase  )  )  )

							for primea in primes:
														_lowerCAmelCase     :							Dict    =    primea * primea
														for primea in primes:
																					_lowerCAmelCase     :							Any    =    primea * primea * primea
																					if square + cube >= limit - 16:
																												break
																					for primea in primes:
																												_lowerCAmelCase     :							Optional[int]    =    primea * primea * primea * primea
																												_lowerCAmelCase     :							Union[str, Any]    =    square + cube + tetr
																												if total >= limit:
																																			break
																												ret.add(_lowerCamelCase  )

							return len(_lowerCamelCase  )


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



from collections import deque

from .hash_table import HashTable







class   __lowercase      (_UpperCAmelCase ):
 def __init__(							self      ,							*A_      ,							**A_					)					->int:



       '''simple docstring'''





       super().__init__(*A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_					)					->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					deque([]					) if self.values[key] is None else self.values[key]
       self.values[key].appendleft(A_					)
       __lowerCAmelCase					:						int					=					self.values[key]
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       return (
           sum(self.charge_factor - len(A_					) for slot in self.values					)
           / self.size_table
           * self.charge_factor
       )





 def 	UpperCamelCase__  (							self      ,							A_      ,							A_=None					)					->str:



       '''simple docstring'''





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


