






from .number_theory.prime_numbers import next_prime




class        _lowerCAmelCase:





       """simple docstring"""







       def __init__(      self						,    _lowerCamelCase						,    _lowerCamelCase = None						,    _lowerCamelCase = None						,    ):
         UpperCamelCase_:      Optional[Any]					   =       size_table
         UpperCamelCase_:      Dict					   =       [None] * self.size_table
         UpperCamelCase_:      Dict					   =       0.7_5 if lim_charge is None else lim_charge
         UpperCamelCase_:      str					   =       1 if charge_factor is None else charge_factor
         UpperCamelCase_:      list					   =       []
         UpperCamelCase_:      dict					   =       {}





       def     _a					(      self							):
         return self._keys





       def     _a					(      self							):
         return sum(1 for slot in self.values if slot is not None							) / (
             self.size_table * self.charge_factor
         )





       def     _a					(      self						,    _lowerCamelCase							):
         return key % self.size_table





       def     _a					(      self						,    _lowerCamelCase							):
         print(f'''step {step_ord}'''							)
         print(list(range(len(self.values							)							)							)							)
         print(self.values							)





       def     _a					(      self						,    _lowerCamelCase							):
         UpperCamelCase_:      List[Any]					   =       1
         UpperCamelCase_:      List[Any]					   =       values
         for value in values:
           self.insert_data(_lowerCamelCase							)
           self._step_by_step(_lowerCamelCase							)
           i += 1





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      Dict					   =       data
         UpperCamelCase_:      int					   =       data





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase=None							):
         UpperCamelCase_:      List[Any]					   =       self.hash_function(key + 1							)

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

         return new_key





       def     _a					(      self							):
         UpperCamelCase_:      Optional[int]					   =       [value for value in self.values if value is not None]
         UpperCamelCase_:      Dict					   =       next_prime(self.size_table						,    factor=2							)
         self._keys.clear()
         UpperCamelCase_:      Optional[Any]					   =       [None] * self.size_table  # hell's pointers D: don't DRY ;/
         for value in survivor_values:
           self.insert_data(_lowerCamelCase							)





       def     _a					(      self						,    _lowerCamelCase							):
         UpperCamelCase_:      List[Any]					   =       self.hash_function(_lowerCamelCase							)

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

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

         else:
           UpperCamelCase_:      Optional[Any]					   =       self._collision_resolution(_lowerCamelCase						,    _lowerCamelCase							)
           if collision_resolution is not None:
             self._set_value(_lowerCamelCase						,    _lowerCamelCase							)
           else:
             self.rehashing()
             self.insert_data(_lowerCamelCase							)







def 						snake_case      (UpperCAmelCase__ = 4_0_0_0_0_0_0						) ->       int:

  if n <= 1:
    return 0
  UpperCamelCase_:      Dict					   =       0
  UpperCamelCase_:      Union[str, Any]					   =       2
  UpperCamelCase_:      int					   =       0
  while 4 * b + a <= n:
    UpperCamelCase_   ,UpperCamelCase_:      List[str]					   =       b, 4 * b + a
    count += a
  return count + b


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