'''simple docstring'''

from ..utils import DummyObject, requires_backends
class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[int]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Any:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Tuple       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[int]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[int]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )



def 							UpperCamelCase__			(			*a__			,      **a__      ):


						'''simple docstring'''






						requires_backends(a__			,      ['torch']      )
class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Any:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Tuple       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[int]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Any       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Union[str, Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     str:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Any       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      int       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Union[str, Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     str:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Union[str, Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Union[str, Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      str       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     str:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Any       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Dict:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Tuple       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      int       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      int       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Any       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     int:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Union[str, Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     int:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      int       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      List[str]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     str:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[str]:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Optional[int]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Optional[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     str:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Optional[Any]       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Union[str, Any]:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     List[Any]:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)

class   SCREAMING_SNAKE_CASE			(						metaclass=__lowercase):







		"""simple docstring"""
		lowercase   :      Dict       =							['torch']






		def __init__(   self		,						*__A		,						**__A				) ->     Dict:
								requires_backends(self		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Any:
								requires_backends(cls		,						['torch']				)






		@classmethod
		def 		UpperCamelCase__       (   cls		,						*__A		,						**__A				) ->     Tuple:
								requires_backends(cls		,						['torch']				)






'''simple docstring'''

from __future__ import annotations

lowercase_     		= 10



def 							UpperCamelCase__			(			a__      ):


						'''simple docstring'''






						_lowerCAmelCase										=1
						_lowerCAmelCase										=max(a__      )
						while placement <= max_digit:
												# declare and initialize empty buckets
												_lowerCAmelCase										=[[] for _ in range(a__      )]
												# split list_of_ints between the buckets
												for i in list_of_ints:
																		_lowerCAmelCase										=int((i / placement) % RADIX      )
																		buckets[tmp].append(a__      )
												# put each buckets' contents into list_of_ints
												_lowerCAmelCase										=0
												for b in range(a__      ):
																		for i in buckets[b]:
																								_lowerCAmelCase										=i
																								a += 1
        # move to next
												placement *= RADIX
						return list_of_ints


if __name__ == "__main__":
							import doctest

							doctest.testmod()





