

'''simple docstring'''
from ..utils import DummyObject, requires_backends







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     int							, **_a				:     Optional[int]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Tuple							, **_a				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Tuple							, **_a				:     Tuple			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     int							, **_a				:     Union[str, Any]			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Optional[int]							, **_a				:     str			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     List[str]							, **_a				:     Optional[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     str							, **_a				:     List[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     str							, **_a				:     Optional[int]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     int							, **_a				:     Tuple			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Union[str, Any]							, *_a				:     Any							, **_a				:     str			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Tuple							, **_a				:     int			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Tuple							, **_a				:     str			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Tuple							, *_a				:     Tuple							, **_a				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     Any							, **_a				:     List[Any]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Any							, **_a				:     Optional[int]			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[Any]							, *_a				:     List[str]							, **_a				:     List[Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     List[Any]							, **_a				:     Optional[Any]			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Dict							, **_a				:     Any			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Dict							, *_a				:     int							, **_a				:     Tuple			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Optional[Any]							, **_a				:     Dict			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     int							, **_a				:     str			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Dict							, *_a				:     Optional[int]							, **_a				:     Optional[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Any							, **_a				:     Optional[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     List[Any]							, **_a				:     Optional[int]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     List[str]							, **_a				:     Dict			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     Union[str, Any]							, **_a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Tuple							, *_a				:     Any							, **_a				:     List[str]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     Any							, **_a				:     int			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Optional[Any]							, **_a				:     Dict			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     str							, **_a				:     Union[str, Any]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     int							, **_a				:     List[str]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Dict							, **_a				:     Dict			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     List[str]							, **_a				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)


def 	_lowerCAmelCase (						*_UpperCamelCase						:					Union[str, Any]							,			**_UpperCamelCase						:					Any    )				->      Union[str, Any]:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					Dict							,			**_UpperCamelCase						:					Union[str, Any]    )				->      Union[str, Any]:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					int							,			**_UpperCamelCase						:					Optional[int]    )				->      Tuple:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					Dict							,			**_UpperCamelCase						:					Any    )				->      Union[str, Any]:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					Optional[int]							,			**_UpperCamelCase						:					List[str]    )				->      Optional[int]:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					int							,			**_UpperCamelCase						:					Union[str, Any]    )				->      List[str]:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )


def 	_lowerCAmelCase (						*_UpperCamelCase						:					Any							,			**_UpperCamelCase						:					List[str]    )				->      Dict:
     """simple docstring"""




     requires_backends(_UpperCamelCase							,			['torch']    )







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     Tuple							, **_a				:     List[Any]			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Tuple							, *_a				:     str							, **_a				:     List[Any]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Optional[Any]							, **_a				:     Dict			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     List[Any]							, **_a				:     str			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     Optional[Any]							, **_a				:     Dict			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Tuple							, **_a				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     Any							, **_a				:     Tuple			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     Optional[int]							, **_a				:     Dict			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     int							, **_a				:     List[str]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     List[str]							, **_a				:     Tuple			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     List[Any]							, **_a				:     Any			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Union[str, Any]							, **_a				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     Optional[int]							, **_a				:     Dict			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Any							, **_a				:     Dict			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     List[str]							, **_a				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[Any]							, *_a				:     Union[str, Any]							, **_a				:     Dict			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     List[Any]							, **_a				:     Union[str, Any]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Any							, **_a				:     int			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[int]							, *_a				:     str							, **_a				:     List[str]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Any							, **_a				:     Union[str, Any]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     Dict							, **_a				:     List[Any]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





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





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     Any							, **_a				:     Optional[int]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Optional[int]							, **_a				:     List[str]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     List[str]							, **_a				:     int			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     str							, **_a				:     Optional[int]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Tuple							, *_a				:     str							, **_a				:     List[str]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Union[str, Any]							, *_a				:     List[Any]							, **_a				:     int			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     Dict							, **_a				:     Optional[int]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     str							, **_a				:     int			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[Any]							, *_a				:     Any							, **_a				:     List[str]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Dict							, **_a				:     Optional[Any]			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     Dict							, **_a				:     str			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[Any]							, *_a				:     Optional[int]							, **_a				:     Optional[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     List[Any]							, **_a				:     Union[str, Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     str							, **_a				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Tuple							, *_a				:     str							, **_a				:     Optional[int]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Tuple							, *_a				:     Tuple							, **_a				:     Dict			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     str							, **_a				:     Tuple			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     str							, **_a				:     Union[str, Any]			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     List[str]							, **_a				:     Tuple			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Dict							, **_a				:     Optional[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     Union[str, Any]							, **_a				:     List[str]			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Optional[int]							, **_a				:     List[Any]			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     int							, **_a				:     Tuple			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[int]							, *_a				:     int							, **_a				:     Tuple			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     Union[str, Any]							, **_a				:     Optional[Any]			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Optional[Any]							, **_a				:     int			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[Any]							, *_a				:     Union[str, Any]							, **_a				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     Optional[int]							, **_a				:     Optional[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     str							, **_a				:     Optional[Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     str							, *_a				:     Any							, **_a				:     Any			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     List[Any]							, **_a				:     List[str]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     Any							, **_a				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     Optional[int]							, **_a				:     Optional[int]			)     ->   str:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Union[str, Any]							, **_a				:     Dict			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     List[Any]							, **_a				:     Optional[int]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     List[Any]							, **_a				:     Union[str, Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Dict							, **_a				:     List[Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Optional[int]							, **_a				:     int			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     List[Any]							, **_a				:     List[Any]			)     ->   str:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Dict							, **_a				:     Union[str, Any]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     List[str]							, **_a				:     Dict			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     str							, **_a				:     List[str]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Dict							, **_a				:     Any			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Dict							, **_a				:     int			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     Optional[Any]							, **_a				:     Any			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     Dict							, **_a				:     List[str]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     List[Any]							, **_a				:     Any			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[int]							, *_a				:     Optional[int]							, **_a				:     List[Any]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     str							, **_a				:     List[str]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Dict							, **_a				:     str			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     Dict							, **_a				:     Tuple			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Optional[int]							, **_a				:     List[str]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Any							, **_a				:     str			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     int							, **_a				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     Dict							, **_a				:     Any			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Dict							, **_a				:     Tuple			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[Any]							, *_a				:     Any							, **_a				:     int			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     List[Any]							, **_a				:     int			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Any							, **_a				:     Dict			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Union[str, Any]							, *_a				:     int							, **_a				:     Optional[int]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Tuple							, **_a				:     Optional[Any]			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     str							, **_a				:     Optional[int]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     Tuple							, **_a				:     Any			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     Any							, **_a				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Any							, **_a				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Union[str, Any]							, *_a				:     Optional[Any]							, **_a				:     Any			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Tuple							, *_a				:     str							, **_a				:     Union[str, Any]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     Optional[Any]							, **_a				:     List[str]			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     List[Any]							, **_a				:     Tuple			)     ->   int:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Optional[int]							, **_a				:     Any			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[str]							, *_a				:     str							, **_a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     Any							, **_a				:     str			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[Any]							, *_a				:     Optional[Any]							, **_a				:     Union[str, Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Optional[Any]							, **_a				:     Optional[int]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     List[str]							, *_a				:     List[str]							, **_a				:     Any			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Optional[Any]							, **_a				:     List[Any]			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     str							, **_a				:     Any			)     ->   Any:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Optional[int]							, *_a				:     Tuple							, **_a				:     str			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Tuple							, **_a				:     str			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     List[Any]							, **_a				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Tuple							, *_a				:     Union[str, Any]							, **_a				:     Tuple			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     List[str]							, **_a				:     Optional[int]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Dict							, *_a				:     List[Any]							, **_a				:     Optional[Any]			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Any							, *_a				:     int							, **_a				:     Any			)     ->   Any:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     str							, *_a				:     List[Any]							, **_a				:     List[Any]			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     List[str]							, **_a				:     Optional[int]			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Dict							, *_a				:     List[str]							, **_a				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     int							, **_a				:     Optional[Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Tuple							, **_a				:     List[str]			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     Dict							, *_a				:     Any							, **_a				:     Dict			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     List[Any]							, *_a				:     Any							, **_a				:     List[str]			)     ->   Dict:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Union[str, Any]							, *_a				:     Union[str, Any]							, **_a				:     List[str]			)     ->   Optional[int]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)







class 							A__   (	metaclass=A__  ):
  A__					=    ['torch']





  def __init__(		self				:     int							, *_a				:     List[Any]							, **_a				:     List[str]			)     ->   List[Any]:





       '''simple docstring'''






       requires_backends(self							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Optional[int]							, *_a				:     Optional[int]							, **_a				:     int			)     ->   Union[str, Any]:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     Optional[Any]							, **_a				:     Optional[Any]			)     ->   int:





       '''simple docstring'''






       requires_backends(cls							, ['torch']			)



'''simple docstring'''
import warnings


warnings.warn(
    "memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: "
    "`from accelerate import find_executable_batch_size` to avoid this warning.",
    FutureWarning,
)
