
from ..utils import DummyObject, requires_backends




class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Dict       )     ->      Union[str, Any]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Any     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Tuple       )     ->      Any:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Tuple     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      int:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Union[str, Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					List[Any]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					int       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Optional[int]     ,				*UpperCamelCase__     :					Optional[int]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Optional[Any]     ,				*UpperCamelCase__     :					List[str]     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					List[str]     ,				**UpperCamelCase__     :					Tuple       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Union[str, Any]     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					List[Any]       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					int     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      str:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					int       )     ->      Any:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Tuple     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Tuple:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Optional[int]       )     ->      str:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Any     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Dict       )     ->      Optional[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					int     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					str       )     ->      List[Any]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					List[Any]       )     ->      Tuple:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )

def a__       (			*A_,	**A_   ):






  '''simple docstring'''





  requires_backends(A_,	["""torch"""]   )




class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







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







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					str       )     ->      int:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







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







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[Any]     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Dict       )     ->      List[str]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







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







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      List[str]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Union[str, Any]     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					Tuple       )     ->      List[str]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					int       )     ->      Tuple:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[str]     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					List[Any]     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					List[Any]       )     ->      int:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Any     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					int     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					str     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Optional[int]       )     ->      str:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Optional[int]     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					str       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[Any]     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Any       )     ->      Optional[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[int]       )     ->      List[Any]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[str]     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Any     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					int       )     ->      Any:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Optional[int]     ,				**UpperCamelCase__     :					Any       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[Any]     ,				*UpperCamelCase__     :					List[str]     ,				**UpperCamelCase__     :					List[str]       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[Any]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Any       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					str     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      Any:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Dict     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					int       )     ->      int:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					List[Any]       )     ->      Any:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Dict     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					str       )     ->      Dict:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Optional[Any]     ,				*UpperCamelCase__     :					Optional[int]     ,				**UpperCamelCase__     :					int       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					Tuple       )     ->      Optional[Any]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					List[str]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Dict:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					List[str]       )     ->      str:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[Any]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					str       )     ->      Union[str, Any]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					List[str]     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					str       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      Any:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					str     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					List[Any]       )     ->      int:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					Tuple       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Union[str, Any]     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					Optional[int]       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					int     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Tuple       )     ->      List[str]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Tuple     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Tuple       )     ->      Union[str, Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Dict       )     ->      Optional[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Any       )     ->      List[str]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Any     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Any       )     ->      List[str]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Tuple       )     ->      List[str]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Optional[Any]     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Optional[int]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Dict     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					Dict       )     ->      Union[str, Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Optional[int]       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					int     ,				*UpperCamelCase__     :					int     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Dict:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Union[str, Any]     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Tuple       )     ->      Any:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Optional[Any]     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      List[Any]:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					str     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      List[str]:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Dict     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					List[Any]       )     ->      Dict:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Tuple     ,				*UpperCamelCase__     :					Tuple     ,				**UpperCamelCase__     :					List[Any]       )     ->      Tuple:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					List[str]     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					str       )     ->      int:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Optional[int]       )     ->      Any:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[Any]     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					List[Any]       )     ->      int:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					List[str]     ,				**UpperCamelCase__     :					Union[str, Any]       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Any     ,				*UpperCamelCase__     :					Optional[int]     ,				**UpperCamelCase__     :					Tuple       )     ->      List[Any]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					str       )     ->      Dict:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Dict     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					str       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					Optional[int]     ,				*UpperCamelCase__     :					List[str]     ,				**UpperCamelCase__     :					int       )     ->      Any:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[str]     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Any       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					List[Any]     ,				**UpperCamelCase__     :					Any       )     ->      Optional[int]:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					str     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					Dict       )     ->      str:







    """simple docstring"""






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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					Dict     ,				**UpperCamelCase__     :					str       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )







class 			UpperCAmelCase_     (					metaclass=_A	):


  '''simple docstring'''







  a__       			=						["""torch"""]
  def __init__(					self     :					List[Any]     ,				*UpperCamelCase__     :					Any     ,				**UpperCamelCase__     :					List[str]       )     ->      int:







    """simple docstring"""






    requires_backends(self     ,				["""torch"""]       )
  @classmethod
  def 				_lowercase				(					cls     :					Tuple     ,				*UpperCamelCase__     :					Union[str, Any]     ,				**UpperCamelCase__     :					Any       )     ->      Tuple:







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )





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







    """simple docstring"""






    requires_backends(cls     ,				["""torch"""]       )



import string

def a__       (			A_   ):






  '''simple docstring'''





  __magic_name__								=			""""""
  for i in sequence:
    __magic_name__								=			ord(A_   )
    if 65 <= extract <= 90:
      output += chr(155 - extract   )
    elif 97 <= extract <= 122:
      output += chr(219 - extract   )
    else:
      output += i
  return output

def a__       (			A_   ):






  '''simple docstring'''





  __magic_name__								=			string.ascii_letters
  __magic_name__								=			string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
  return "".join(
      letters_reversed[letters.index(A_   )] if c in letters else c for c in sequence   )

def a__       (			):






  '''simple docstring'''





  from timeit import timeit

  print("""Running performance benchmarks..."""   )
  __magic_name__								=			"""from string import printable ; from __main__ import atbash, atbash_slow"""
  print(f'''> atbash_slow(): {timeit('atbash_slow(printable)',	setup=A_   )} seconds'''   )
  print(f'''>      atbash(): {timeit('atbash(printable)',	setup=A_   )} seconds'''   )


if __name__ == "__main__":
    for example in ("ABCDEFGH", "123GGjj", "testStringtest", "with space"):
        print(F'''{example} encrypted in atbash: {atbash(example)}''')
    benchmark()

