




from ..utils import DummyObject, requires_backends




class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Any       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					int       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Union[str, Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Union[str, Any]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					int       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)







def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )



def       UpperCAmelCase__  (     *lowerCamelCase,			**lowerCamelCase   ):
  requires_backends(lowerCamelCase,			["torch"]   )




class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					int       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Any       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					str       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Any       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					str				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[Any]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[str]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					str       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Tuple       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					str				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[str]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					List[Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Tuple       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					str				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Dict       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[int]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Tuple       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[Any]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Any       ,					*_lowerCAmelCase:					Any       ,					**_lowerCAmelCase:					Dict				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					Tuple       ,					**_lowerCAmelCase:					List[str]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					Union[str, Any]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[str]       ,					*_lowerCAmelCase:					Dict       ,					**_lowerCAmelCase:					str				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					int       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					str				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Union[str, Any]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					List[Any]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					str       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Union[str, Any]				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					List[str]       ,					*_lowerCAmelCase:					Optional[Any]       ,					**_lowerCAmelCase:					int				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Dict       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					str       ,					*_lowerCAmelCase:					List[str]       ,					**_lowerCAmelCase:					Optional[int]				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					str       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Any				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					List[str]       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[int]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					int				):
         requires_backends(cls       ,					["torch"]				)







class    __lowerCAmelCase       (							metaclass=lowerCAmelCase):
       _a 					=						['''torch''']






       def __init__(   self:					Optional[Any]       ,					*_lowerCAmelCase:					Optional[int]       ,					**_lowerCAmelCase:					Optional[Any]				):
         requires_backends(self       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Optional[Any]       ,					*_lowerCAmelCase:					str       ,					**_lowerCAmelCase:					Any				):
         requires_backends(cls       ,					["torch"]				)






       @classmethod
       def 					SCREAMING_SNAKE_CASE    (   cls:					Any       ,					*_lowerCAmelCase:					int       ,					**_lowerCAmelCase:					Tuple				):
         requires_backends(cls       ,					["torch"]				)









import string



def       UpperCAmelCase__  (     lowerCamelCase   ):
  lowercase    :Optional[int]      	=						""
  for i in sequence:
    lowercase    :Optional[Any]      	=						ord(lowerCamelCase   )
    if 65 <= extract <= 90:
      output += chr(155 - extract   )
    elif 97 <= extract <= 122:
      output += chr(219 - extract   )
    else:
      output += i
  return output



def       UpperCAmelCase__  (     lowerCamelCase   ):
  lowercase    :Union[str, Any]      	=						string.ascii_letters
  lowercase    :Dict      	=						string.ascii_lowercase[::-1] + string.ascii_uppercase[::-1]
  return "".join(
      letters_reversed[letters.index(lowerCamelCase   )] if c in letters else c for c in sequence   )



def       UpperCAmelCase__  (     ):
  from timeit import timeit

  print("Running performance benchmarks..."   )
  lowercase    :Dict      	=						"from string import printable ; from __main__ import atbash, atbash_slow"
  print(F"> atbash_slow(): {timeit('atbash_slow(printable)',			setup=lowerCamelCase   )} seconds"   )
  print(F">      atbash(): {timeit('atbash(printable)',			setup=lowerCamelCase   )} seconds"   )


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



