code: 
  
  
  """simple docstring"""
  from .number_theory.prime_numbers import next_prime
  
  
  
  
  class   lowercase__							:
  
  
  
  
  
     def __init__(       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE = None			,      SCREAMING_SNAKE_CASE = None			,      )     ->     None:
        _lowerCamelCase  :				Optional[Any]      =		size_table
        _lowerCamelCase  :				Tuple      =		[None] * self.size_table
        _lowerCamelCase  :				Any      =		0.75 if lim_charge is None else lim_charge
        _lowerCamelCase  :				List[str]      =		1 if charge_factor is None else charge_factor
        _lowerCamelCase  :				list      =		[]
        _lowerCamelCase  :				dict      =		{}
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     List[str]:
        return self._keys
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     Dict:
        return sum(1 for slot in self.values if slot is not None) / (
            self.size_table * self.charge_factor
        )
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     Any:
        return key % self.size_table
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     List[str]:
        print(F'step {step_ord}')
        print(list(range(len(self.values))))
        print(self.values)
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     Optional[Any]:
        _lowerCamelCase  :				Dict      =		1
        _lowerCamelCase  :				int      =		values
        for value in values:
           self.insert_data(SCREAMING_SNAKE_CASE)
           self._step_by_step(SCREAMING_SNAKE_CASE)
           i += 1
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE)     ->     Optional[int]:
        _lowerCamelCase  :				List[Any]      =		data
        _lowerCamelCase  :				Union[str, Any]      =		data
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE=None)     ->     List[Any]:
        _lowerCamelCase  :				str      =		self.hash_function(key + 1)
  
        while self.values[new_key] is not None and self.values[new_key] != key:
           if self.values.count(SCREAMING_SNAKE_CASE) > 0:
              _lowerCamelCase  :				Optional[int]      =		self.hash_function(new_key + 1)
           else:
              _lowerCamelCase  :				Any      =		None
              break
  
        return new_key
  
  
  
  
  
     def 		UpperCamelCase_     (       self)     ->     Optional[Any]:
        _lowerCamelCase  :				Dict      =		[value for value in self.values if value is not None]
        _lowerCamelCase  :				str      =		next_prime(self.size_table			,      factor=2)
        self._keys.clear()
        _lowerCamelCase  :				Dict      =		[None] * self.size_table  # hell's pointers D: don't DRY ;/
        for value in survivor_values:
           self.insert_data(SCREAMING_SNAKE_CASE)
  
  
  
  
  
     def 		UpperCamelCase_     (       self			,      SCREAMING_SNAKE_CASE)     ->     Any:
        _lowerCamelCase  :				Dict      =		self.hash_function(SCREAMING_SNAKE_CASE)
  
        if self.values[key] is None:
           self._set_value(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE)
  
        elif self.values[key] == data:
           pass
  
        else:
           _lowerCamelCase  :				List[str]      =		self._collision_resolution(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE)
           if collision_resolution is not None:
              self._set_value(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE)
           else:
              self.rehashing()
              self.insert_data(SCREAMING_SNAKE_CASE)
  
  
style_context: 
  
  
  """simple docstring"""
  import timeit
  
  
  
  
  class   lowercase__							:
  
  
  
  
  
     def __init__(       self			,      SCREAMING_SNAKE_CASE)     ->     Tuple:
        if isinstance(SCREAMING_SNAKE_CASE			,      SCREAMING_SNAKE_CASE):  # Initializes a matrix identical to the one provided.
           _lowerCamelCase  :				List[str]      =		arg
           _lowerCamelCase  :				List[str]      =		len(SCREAMING_SNAKE_CASE)
        else:  # Initializes a square matrix of the given size and set values to zero.
           _lowerCamelCase  :				List[Any]      =		arg
           _lowerCamelCase  :				Union[str, Any]      =		[[0 for _ in range(self.n)] for _ in range(self.n)]
  
  
  
  
  
     def __mul__(       self			,      SCREAMING_SNAKE_CASE)     ->     Optional[Any]:
        _lowerCamelCase  :				List[Any]      =		Matrix(self.n)
        for i in range(self.n):
           for j in range(self.n):
              for k in range(self.n):
                 matrix.t[i][j] += self.t[i][k] * b.t[k][j]
        return matrix
  
  
  
  
  
  
  
  def 							_snake_case			(      __snake_case       :			Union[str, Any]	,   __snake_case       :			List[Any]      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				List[Any]      =		Matrix([[1, 0], [0, 1]]      )
     while b > 0:
        if b & 1:
           matrix *= a
        a *= a
        b >>= 1
     return matrix
  
  def 							_snake_case			(      __snake_case       :			List[str]	,   __snake_case       :			str	,   __snake_case       :			List[Any]      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     if n == 1:
        return fa
     elif n == 2:
        return fa
     _lowerCamelCase  :				Any      =		Matrix([[1, 1], [1, 0]]      )
     _lowerCamelCase  :				List[str]      =		modular_exponentiation(__snake_case	,   n - 2      )
     return fa * matrix.t[0][0] + fa * matrix.t[0][1]
  
  def 							_snake_case			(      __snake_case       :			int	,   __snake_case       :			Optional[int]	,   __snake_case       :			List[Any]      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     if n == 1:
        return fa
     elif n == 2:
        return fa
  
     _lowerCamelCase  :				Optional[Any]      =		fa
     _lowerCamelCase  :				int      =		fa
     n -= 2
  
     while n > 0:
        _lowerCamelCase      ,						_lowerCamelCase  :				Tuple      =		fn_a + fn_a, fn_a
        n -= 1
  
     return fn_a
  
  def 							_snake_case			(      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				List[str]      =		"""
  from random import randint
  from __main__ import fibonacci_with_matrix_exponentiation
  """
     _lowerCamelCase  :				int      =		"""fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)"""
     _lowerCamelCase  :				Tuple      =		timeit.timeit(setup=__snake_case	,   stmt=__snake_case	,   number=100      )
     print("""With matrix exponentiation the average execution time is """	,   exec_time / 100      )
     return exec_time
  
  def 							_snake_case			(      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _lowerCamelCase  :				Dict      =		"""
  from random import randint
  from __main__ import simple_fibonacci
  """
     _lowerCamelCase  :				Optional[int]      =		"""simple_fibonacci(randint(1,70000), 1, 1)"""
     _lowerCamelCase  :				List[Any]      =		timeit.timeit(setup=__snake_case	,   stmt=__snake_case	,   number=100      )
     print(
         """Without matrix exponentiation the average execution time is """	,   exec_time / 100      )
     return exec_time
  
  def 							_snake_case			(      ):
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     matrix_exponentiation_time()
     simple_fibonacci_time()
  
  
  if __name__ == "__main__":
   main()
  
  