






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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				str       ,   *__lowercase						:				int       ,   **__lowercase						:				str   )						->    List[str]:
       requires_backends(cls       ,   ['''torch''']   )






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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





def 			_a(	*UpperCamelCase__					:    int,						**UpperCamelCase__					:    Optional[int]				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    Union[str, Any],						**UpperCamelCase__					:    Optional[Any]				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    Optional[Any],						**UpperCamelCase__					:    Dict				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    Optional[int],						**UpperCamelCase__					:    Optional[Any]				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    Optional[int],						**UpperCamelCase__					:    str				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    Tuple,						**UpperCamelCase__					:    List[Any]				):




      '''simple docstring'''






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





def 			_a(	*UpperCamelCase__					:    List[str],						**UpperCamelCase__					:    List[Any]				):




      '''simple docstring'''






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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				List[Any]       ,   *__lowercase						:				int       ,   **__lowercase						:				List[Any]   )						->    int:
       requires_backends(cls       ,   ['''torch''']   )






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




 @classmethod
 def   __magic_name__						(   cls						:				Any       ,   *__lowercase						:				Optional[Any]       ,   **__lowercase						:				Optional[Any]   )						->    Tuple:
       requires_backends(cls       ,   ['''torch''']   )




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				Any       ,   *__lowercase						:				List[Any]       ,   **__lowercase						:				int   )						->    Any:
       requires_backends(cls       ,   ['''torch''']   )






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




 @classmethod
 def   __magic_name__						(   cls						:				Dict       ,   *__lowercase						:				str       ,   **__lowercase						:				str   )						->    Dict:
       requires_backends(cls       ,   ['''torch''']   )




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				Dict       ,   *__lowercase						:				Dict       ,   **__lowercase						:				str   )						->    Tuple:
       requires_backends(cls       ,   ['''torch''']   )






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




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






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				Tuple       ,   *__lowercase						:				Dict       ,   **__lowercase						:				str   )						->    Tuple:
       requires_backends(cls       ,   ['''torch''']   )






class   __SCREAMING_SNAKE_CASE   (      metaclass=_A					):
 snake_case_					=				["""torch"""]




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




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




 @classmethod
 def   __magic_name__						(   cls						:				Dict       ,   *__lowercase						:				Dict       ,   **__lowercase						:				Optional[Any]   )						->    int:
       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()

