


"""simple docstring"""







def    UpperCAmelCase__       (lowerCAmelCase_  ,						lowerCAmelCase_   ):




					'''simple docstring'''


					while b:
										__SCREAMING_SNAKE_CASE   ,  __SCREAMING_SNAKE_CASE						   =				b, a % b
					return a




def    UpperCAmelCase__       (lowerCAmelCase_  ,						lowerCAmelCase_   ):




					'''simple docstring'''


					return a if b == 0 else euclidean_gcd_recursive(lowerCAmelCase_  ,						a % b   )




def    UpperCAmelCase__       ():




					'''simple docstring'''


					print(f"""euclidean_gcd(3, 5) = {euclidean_gcd(3  ,						5   )}"""   )
					print(f"""euclidean_gcd(5, 3) = {euclidean_gcd(5  ,						3   )}"""   )
					print(f"""euclidean_gcd(1, 3) = {euclidean_gcd(1  ,						3   )}"""   )
					print(f"""euclidean_gcd(3, 6) = {euclidean_gcd(3  ,						6   )}"""   )
					print(f"""euclidean_gcd(6, 3) = {euclidean_gcd(6  ,						3   )}"""   )

					print(f"""euclidean_gcd_recursive(3, 5) = {euclidean_gcd_recursive(3  ,						5   )}"""   )
					print(f"""euclidean_gcd_recursive(5, 3) = {euclidean_gcd_recursive(5  ,						3   )}"""   )
					print(f"""euclidean_gcd_recursive(1, 3) = {euclidean_gcd_recursive(1  ,						3   )}"""   )
					print(f"""euclidean_gcd_recursive(3, 6) = {euclidean_gcd_recursive(3  ,						6   )}"""   )
					print(f"""euclidean_gcd_recursive(6, 3) = {euclidean_gcd_recursive(6  ,						3   )}"""   )


if __name__ == "__main__":
		main()





from collections import deque

from .hash_table import HashTable




class 					snake_case__						(       lowerCAmelCase_     ):






     """simple docstring"""


     def __init__(       self  :  Optional[Any], *_snake_case  :  Optional[Any], **_snake_case  :  List[Any]					)   ->Optional[int]:
            super().__init__(*_snake_case, **_snake_case					)






     def    lowercase_   (       self  :  Optional[Any], _snake_case  :  Tuple, _snake_case  :  Dict					)   ->Dict:
            snake_case__							:	int   	=	deque([]					) if self.values[key] is None else self.values[key]
            self.values[key].appendleft(_snake_case					)
            snake_case__							:	Dict   	=	self.values[key]






     def    lowercase_   (       self  :  Any					)   ->Optional[Any]:
            return (
                sum(self.charge_factor - len(_snake_case					) for slot in self.values					)
                / self.size_table
                * self.charge_factor
            )






     def    lowercase_   (       self  :  Union[str, Any], _snake_case  :  str, _snake_case  :  Optional[int]=None					)   ->Optional[Any]:
            if not (
                len(self.values[key]					) == self.charge_factor and self.values.count(_snake_case					) == 0
            ):
                   return key
            return super()._collision_resolution(_snake_case, _snake_case					)






