



from ..utils import DummyObject, requires_backends






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    str)->							Optional[int]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    int)->							Any:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Any)->							int:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    str)->							Union[str, Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    Any				,	**snake_case_							:    Union[str, Any])->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    str				,	**snake_case_							:    Union[str, Any])->							List[str]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    Any				,	**snake_case_							:    Optional[int])->							int:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Optional[int])->							List[str]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Optional[int])->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    str				,	**snake_case_							:    str)->							str:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Any				,	**snake_case_							:    Tuple)->							Tuple:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    int				,	**snake_case_							:    Any)->							Any:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Optional[int]				,	*snake_case_							:    int				,	**snake_case_							:    str)->							Optional[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Tuple)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    str)->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Optional[Any]				,	*snake_case_							:    str				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Tuple				,	**snake_case_							:    Union[str, Any])->							Any:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Union[str, Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Any				,	**snake_case_							:    Optional[Any])->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Optional[Any])->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    List[Any])->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[str]				,	*snake_case_							:    List[str]				,	**snake_case_							:    List[Any])->							Tuple:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Tuple)->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Tuple				,	**snake_case_							:    Union[str, Any])->							List[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    str)->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Any)->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    str				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[str]				,	*snake_case_							:    List[str]				,	**snake_case_							:    Any)->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Dict)->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    str				,	**snake_case_							:    Any)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Tuple				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Union[str, Any])->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Tuple				,	**snake_case_							:    Tuple)->							List[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    List[str]				,	**snake_case_							:    Any)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    Any				,   **__lowerCamelCase	:    Any	)  ->						Optional[Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    Dict				,   **__lowerCamelCase	:    Tuple	)  ->						Optional[Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    Optional[Any]				,   **__lowerCamelCase	:    Optional[int]	)  ->						Union[str, Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    Optional[int]				,   **__lowerCamelCase	:    List[str]	)  ->						List[Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    List[str]				,   **__lowerCamelCase	:    int	)  ->						List[Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    List[Any]				,   **__lowerCamelCase	:    List[str]	)  ->						Dict:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






def 					__lowerCAmelCase		(  *__lowerCamelCase	:    Optional[Any]				,   **__lowerCamelCase	:    Union[str, Any]	)  ->						Union[str, Any]:
					requires_backends(__lowerCamelCase				,   ["""torch"""]	)






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    int)->							str:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Dict				,	**snake_case_							:    Union[str, Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Dict				,	**snake_case_							:    List[str])->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Dict)->							Union[str, Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    int)->							List[str]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    List[str])->							Tuple:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Optional[int])->							List[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Any				,	**snake_case_							:    Dict)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    Any				,	**snake_case_							:    Optional[int])->							Tuple:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    int				,	**snake_case_							:    Union[str, Any])->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    List[str])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    int				,	**snake_case_							:    List[Any])->							List[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Any				,	**snake_case_							:    int)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    int				,	**snake_case_							:    int)->							Any:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Any)->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    List[Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Optional[int])->							int:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Dict				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Optional[Any])->							List[str]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    str				,	**snake_case_							:    List[str])->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    int				,	**snake_case_							:    Any)->							List[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[str])->							List[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    List[str]				,	**snake_case_							:    Union[str, Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    int				,	**snake_case_							:    List[Any])->							str:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    Tuple				,	**snake_case_							:    Any)->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Union[str, Any])->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    Dict				,	**snake_case_							:    Dict)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Optional[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    str)->							List[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Union[str, Any])->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Dict				,	**snake_case_							:    Union[str, Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Dict				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[str])->							int:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    int				,	**snake_case_							:    str)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Tuple				,	**snake_case_							:    Any)->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    str				,	**snake_case_							:    Optional[Any])->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Tuple)->							Any:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Tuple				,	**snake_case_							:    Union[str, Any])->							str:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Any				,	**snake_case_							:    Tuple)->							Tuple:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    List[str]				,	**snake_case_							:    Any)->							Dict:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Union[str, Any])->							List[str]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    int				,	**snake_case_							:    Any)->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    Dict				,	**snake_case_							:    int)->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Tuple)->							int:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    List[Any]				,	**snake_case_							:    List[Any])->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Tuple				,	**snake_case_							:    Optional[int])->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Tuple				,	**snake_case_							:    Union[str, Any])->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Optional[int])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    str)->							Any:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    int				,	**snake_case_							:    Optional[Any])->							List[str]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    str)->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    List[str]				,	**snake_case_							:    Optional[Any])->							int:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Dict)->							Optional[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    List[str])->							Any:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    int				,	**snake_case_							:    Optional[Any])->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Dict				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Dict)->							Optional[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Tuple)->							List[str]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    Tuple				,	**snake_case_							:    Optional[int])->							str:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Optional[int]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Any)->							List[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    Tuple				,	**snake_case_							:    int)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Optional[Any])->							List[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Optional[int]				,	*snake_case_							:    Dict				,	**snake_case_							:    int)->							Optional[Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Tuple				,	**snake_case_							:    List[Any])->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Any				,	**snake_case_							:    Tuple)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Dict)->							int:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    str				,	**snake_case_							:    int)->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Tuple				,	**snake_case_							:    Tuple)->							Any:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Optional[int])->							Tuple:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[Any]				,	*snake_case_							:    Any				,	**snake_case_							:    List[str])->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Tuple				,	**snake_case_							:    str)->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Dict)->							List[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    int)->							int:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    List[Any]				,	**snake_case_							:    int)->							Union[str, Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    List[Any]				,	**snake_case_							:    str)->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Any)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Optional[int])->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Dict)->							List[str]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Any)->							Any:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    str				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    Dict)->							Optional[int]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    Tuple				,	**snake_case_							:    Optional[Any])->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Union[str, Any])->							str:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    int				,	**snake_case_							:    Dict)->							Tuple:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Dict)->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Union[str, Any]				,	*snake_case_							:    int				,	**snake_case_							:    Union[str, Any])->							Dict:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[Any])->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    str)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Any				,	**snake_case_							:    Any)->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Tuple				,	*snake_case_							:    Dict				,	**snake_case_							:    Optional[Any])->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    Dict				,	**snake_case_							:    List[str])->							Tuple:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Tuple)->							Dict:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[Any])->							Optional[int]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    str				,	**snake_case_							:    Dict)->							Any:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Union[str, Any])->							Dict:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[str]				,	*snake_case_							:    str				,	**snake_case_							:    List[Any])->							Union[str, Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Any				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Tuple)->							List[str]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    List[str]				,	**snake_case_							:    int)->							List[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[Any])->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    List[Any]				,	**snake_case_							:    List[str])->							str:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Optional[int])->							Tuple:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    str				,	**snake_case_							:    int)->							str:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    str				,	**snake_case_							:    Dict)->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Tuple				,	**snake_case_							:    Optional[Any])->							Optional[int]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Any				,	*snake_case_							:    Tuple				,	**snake_case_							:    Tuple)->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Optional[Any]				,	**snake_case_							:    List[Any])->							int:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Tuple				,	**snake_case_							:    Union[str, Any])->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    int				,	*snake_case_							:    List[str]				,	**snake_case_							:    int)->							Dict:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    str				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Optional[Any])->							Optional[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Optional[int]				,	*snake_case_							:    str				,	**snake_case_							:    Tuple)->							List[Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    List[Any]				,	*snake_case_							:    Optional[int]				,	**snake_case_							:    Dict)->							str:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    List[Any]				,	**snake_case_							:    str)->							List[Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[str]				,	*snake_case_							:    List[Any]				,	**snake_case_							:    str)->							List[str]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Union[str, Any]				,	*snake_case_							:    Tuple				,	**snake_case_							:    str)->							Union[str, Any]:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    List[Any]				,	*snake_case_							:    Any				,	**snake_case_							:    Dict)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Tuple				,	*snake_case_							:    List[Any]				,	**snake_case_							:    Tuple)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])






class 						__a (     metaclass=SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       ["torch"]



	def __init__(						self							:    Dict				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    Tuple)->							Any:
						requires_backends(self				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    int				,	*snake_case_							:    Any				,	**snake_case_							:    Tuple)->							Union[str, Any]:
						requires_backends(cls				,	["""torch"""])



	@classmethod
	def 		UpperCamelCase							(						cls							:    Dict				,	*snake_case_							:    Union[str, Any]				,	**snake_case_							:    str)->							List[Any]:
						requires_backends(cls				,	["""torch"""])









def 					__lowerCAmelCase		(  __lowerCamelCase	:    int	)  ->						list:
					__lowerCAmelCase	   =int(__lowerCamelCase	)
					if n_element < 1:
										__lowerCAmelCase	   =ValueError("""a should be a positive number"""	)
										raise my_error

					__lowerCAmelCase	   =[1]
					__lowerCAmelCase   ,	__lowerCAmelCase   ,	__lowerCAmelCase	   =(0, 0, 0)
					__lowerCAmelCase	   =1
					while index < n_element:
										while hamming_list[i] * 2 <= hamming_list[-1]:
															i += 1
										while hamming_list[j] * 3 <= hamming_list[-1]:
															j += 1
										while hamming_list[k] * 5 <= hamming_list[-1]:
															k += 1
										hamming_list.append(
										    min(hamming_list[i] * 2				,   hamming_list[j] * 3				,   hamming_list[k] * 5	)	)
										index += 1
					return hamming_list


if __name__ == "__main__":
				lowercase_	       =			input('''Enter the last number (nth term) of the Hamming Number Series: ''')
				print('''Formula of Hamming Number Series => 2^i * 3^j * 5^k''')
				lowercase_	       =			hamming(int(n))
				print('''-----------------------------------------------------''')
				print(F"The list with nth numbers is: {hamming_numbers}")
				print('''-----------------------------------------------------''')




