

from ..utils import DummyObject, requires_backends






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Dict      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Optional[Any]      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	Optional[int]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	Dict      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	List[str]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Optional[Any]      )	->							int:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Any      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Tuple      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	int      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Dict      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Dict      )	->							int:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	List[Any]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	List[str]      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	List[str]      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Optional[int]      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	str      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Optional[int]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	List[Any]      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	List[str]      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	str      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Dict      )	->							int:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Any      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Tuple      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Dict      )	->							Any:
							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  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Dict      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	str      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	List[str]      )	->							str:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	Optional[Any]      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	int      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	List[str]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	str      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	List[Any]      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	Dict      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Optional[int]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Tuple      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	str      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Union[str, Any]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	int      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	str      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Tuple      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	int      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	Optional[int]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Dict			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Tuple      )	->							Optional[int]:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Dict      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Tuple      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	str      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	List[str]      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	str      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	str      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Optional[Any]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	int      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	List[Any]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







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






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	int      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	int      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	int      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Dict      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	int      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	str      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Dict      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	str      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	str			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	List[Any]      )	->							Dict:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	Dict      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Any      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Optional[int]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Dict      )	->							List[str]:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	str      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Tuple      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Dict      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	List[str]      )	->							str:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	str      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	Dict      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Tuple			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	Dict      )	->							Optional[int]:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Tuple      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	Optional[Any]      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Optional[int]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	int      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	Dict      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Optional[int]      )	->							str:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Any			,     **__lowerCamelCase		:	List[str]      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Any      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	List[Any]      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	Dict      )	->							int:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	List[Any]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Dict      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	List[str]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	Optional[Any]      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	Union[str, Any]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Any      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	Union[str, Any]      )	->							str:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	List[Any]      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	Tuple      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Tuple      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	List[Any]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	List[Any]      )	->							int:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Union[str, Any]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Optional[Any]      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	Optional[Any]			,     **__lowerCamelCase		:	Tuple      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	List[str]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	int      )	->							List[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Optional[int]			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	List[str]      )	->							List[str]:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	Optional[Any]      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	List[str]      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	str			,     *__lowerCamelCase		:	Tuple			,     **__lowerCamelCase		:	List[Any]      )	->							Optional[int]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Optional[int]			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	Optional[Any]      )	->							Union[str, Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






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






		@classmethod
		def    lowercase_	(							cls		:	Dict			,     *__lowerCamelCase		:	int			,     **__lowerCamelCase		:	str      )	->							List[str]:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	Tuple			,     *__lowerCamelCase		:	str			,     **__lowerCamelCase		:	List[str]      )	->							Optional[Any]:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Optional[Any]			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Dict      )	->							Any:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	Optional[Any]			,     *__lowerCamelCase		:	Optional[int]			,     **__lowerCamelCase		:	Dict      )	->							str:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	List[Any]			,     **__lowerCamelCase		:	str      )	->							Any:
							requires_backends(cls			,     ['''torch''']      )






class  UpperCAmelCase__	( metaclass=_UpperCAmelCase ):






		"""simple docstring"""


		a     =      ["torch"]






		def __init__(							self		:	Optional[Any]			,     *__lowerCamelCase		:	Dict			,     **__lowerCamelCase		:	Optional[Any]      )	->							List[str]:
							requires_backends(self			,     ['''torch''']      )






		@classmethod
		def    lowercase_	(							cls		:	Any			,     *__lowerCamelCase		:	List[str]			,     **__lowerCamelCase		:	Any      )	->							Tuple:
							requires_backends(cls			,     ['''torch''']      )







		@classmethod
		def    lowercase_	(							cls		:	int			,     *__lowerCamelCase		:	Union[str, Any]			,     **__lowerCamelCase		:	Optional[Any]      )	->							Dict:
							requires_backends(cls			,     ['''torch''']      )





import random
def        UpperCAmelCase_     (		_A   ,	_A   ,	_A       ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					a[left_index]
     SCREAMING_SNAKE_CASE__					=					left_index + 1
     for j in range(left_index + 1   ,	_A       ):
          if a[j] < pivot:
               SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					a[i], a[j]
               i += 1
     SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					a[i - 1], a[left_index]
     return i - 1
def        UpperCAmelCase_     (		_A   ,	_A   ,	_A       ):





     '''simple docstring'''




     if left < right:
          SCREAMING_SNAKE_CASE__					=					random.randint(_A   ,	right - 1       )
          SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					(
              a[left],
              a[pivot],
          )  # switches the pivot with the left most bound
          SCREAMING_SNAKE_CASE__					=					partition(_A   ,	_A   ,	_A       )
          quick_sort_random(
              _A   ,	_A   ,	_A       )  # recursive quicksort to the left of the pivot point
          quick_sort_random(
              _A   ,	pivot_index + 1   ,	_A       )  # recursive quicksort to the right of the pivot point
def        UpperCAmelCase_     (		):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					input('''Enter numbers separated by a comma:\n'''       ).strip()
     SCREAMING_SNAKE_CASE__					=					[int(_A       ) for item in user_input.split(''','''       )]

     quick_sort_random(_A   ,	0   ,	len(_A       )       )

     print(_A       )


if __name__ == "__main__":
       main()


