






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


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[int]									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							Tuple	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							Union[str, Any]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							Dict	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Dict									=     ['torch']




    def __init__(      self	:							Any	,  *a	:							Tuple	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Tuple	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							Any	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							Any	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							Tuple	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[int]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: str									=     ['torch']




    def __init__(      self	:							Union[str, Any]	,  *a	:							Any	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							List[Any]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							str	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							Any	,  *a	:							List[str]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							List[Any]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							int	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: int									=     ['torch']




    def __init__(      self	:							Dict	,  *a	:							Dict	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Optional[int]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							List[str]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Dict									=     ['torch']




    def __init__(      self	:							int	,  *a	:							Dict	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							int	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[int]	,  *a	:							List[str]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Tuple									=     ['torch']




    def __init__(      self	:							Dict	,  *a	:							Optional[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[int]	,  *a	:							Optional[Any]	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							str	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[int]									=     ['torch']




    def __init__(      self	:							Any	,  *a	:							List[Any]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							Optional[int]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Optional[int]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[int]									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							Any	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							List[str]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Union[str, Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							str	,  *a	:							List[str]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							str	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							List[str]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)




def 		__SCREAMING_SNAKE_CASE       (	*_UpperCamelCase    ,		**_UpperCamelCase				):


   """simple docstring"""




   requires_backends(_UpperCamelCase    ,		["torch"]				)


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							str	,  *a	:							int	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							int	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Union[str, Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: int									=     ['torch']




    def __init__(      self	:							Optional[int]	,  *a	:							Union[str, Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Union[str, Any]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							Union[str, Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Tuple									=     ['torch']




    def __init__(      self	:							Optional[int]	,  *a	:							Tuple	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							Dict	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							Dict	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[Any]									=     ['torch']




    def __init__(      self	:							Dict	,  *a	:							Optional[int]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Dict	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							Any	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Union[str, Any]									=     ['torch']




    def __init__(      self	:							str	,  *a	:							Tuple	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[int]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							Optional[int]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							List[str]	,  *a	:							Dict	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							Any	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Optional[Any]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							Any	,  *a	:							Tuple	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Optional[int]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[Any]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Dict									=     ['torch']




    def __init__(      self	:							Dict	,  *a	:							Optional[Any]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							List[Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							Any	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							List[str]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							Optional[int]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Any	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							Optional[Any]	,  *a	:							Tuple	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							str	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[int]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Dict									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							Tuple	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Any	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							Tuple	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[Any]									=     ['torch']




    def __init__(      self	:							str	,  *a	:							List[Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							str	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							str	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							str	,  *a	:							int	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							str	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							Optional[Any]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							List[Any]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							str	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							List[Any]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Dict									=     ['torch']




    def __init__(      self	:							List[str]	,  *a	:							List[str]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							List[Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							List[str]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							Optional[int]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							Optional[Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							List[Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[Any]									=     ['torch']




    def __init__(      self	:							Any	,  *a	:							Dict	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							Optional[Any]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							List[str]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							Any	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							int	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							List[Any]	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							Dict	,  *a	:							List[str]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							List[Any]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							List[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: str									=     ['torch']




    def __init__(      self	:							int	,  *a	:							Union[str, Any]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							Dict	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							List[Any]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Union[str, Any]									=     ['torch']




    def __init__(      self	:							int	,  *a	:							Any	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							Dict	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Any	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: int									=     ['torch']




    def __init__(      self	:							Optional[int]	,  *a	:							int	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							Optional[Any]	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[str]									=     ['torch']




    def __init__(      self	:							Optional[int]	,  *a	:							Any	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							str	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Optional[int]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							List[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							str	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							int	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: int									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							Dict	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							Tuple	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							Optional[Any]	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Any									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							List[str]	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							str	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Tuple	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: str									=     ['torch']




    def __init__(      self	:							List[str]	,  *a	:							int	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							Optional[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							List[str]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: List[Any]									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							List[Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							str	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							Union[str, Any]	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Tuple									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							List[Any]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							List[Any]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							str	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: int									=     ['torch']




    def __init__(      self	:							Union[str, Any]	,  *a	:							Optional[Any]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							Any	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[Any]	,  *a	:							Dict	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							List[str]	,  *a	:							List[str]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Optional[int]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							str	,  *a	:							Any	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							Tuple	,  *a	:							str	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							int	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Any	,  *a	:							Union[str, Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Tuple									=     ['torch']




    def __init__(      self	:							str	,  *a	:							List[str]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Tuple	,  *a	:							str	,  **a	:							Optional[int]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Optional[Any]	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Tuple									=     ['torch']




    def __init__(      self	:							Union[str, Any]	,  *a	:							Any	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Tuple	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Union[str, Any]	,  **a	:							List[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[int]									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							List[str]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							str	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[Any]	,  *a	:							int	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[int]									=     ['torch']




    def __init__(      self	:							Optional[Any]	,  *a	:							Any	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							Any	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							int	,  *a	:							List[str]	,  **a	:							str      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Union[str, Any]									=     ['torch']




    def __init__(      self	:							Optional[int]	,  *a	:							Dict	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Optional[Any]	,  **a	:							List[str]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Union[str, Any]	,  *a	:							Dict	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Optional[Any]									=     ['torch']




    def __init__(      self	:							List[str]	,  *a	:							Dict	,  **a	:							Any      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Optional[int]	,  *a	:							Optional[int]	,  **a	:							int      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							List[str]	,  *a	:							int	,  **a	:							Union[str, Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )


class 							_UpperCAmelCase    (		metaclass=snake_case      ):
    __lowerCamelCase: Union[str, Any]									=     ['torch']




    def __init__(      self	:							List[Any]	,  *a	:							str	,  **a	:							Tuple      ):






       '''simple docstring'''






       requires_backends(self	,  ["torch"]      )




    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Dict	,  **a	:							Optional[Any]      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )





    @classmethod
    def 					lowerCAmelCase__					(      cls	:							Dict	,  *a	:							Optional[int]	,  **a	:							Dict      ):






       '''simple docstring'''






       requires_backends(cls	,  ["torch"]      )












'''simple docstring'''
UpperCamelCase__			=      {
    "joule": 1.0,
    "kilojoule": 1000,
    "megajoule": 1000000,
    "gigajoule": 1000000000,
    "wattsecond": 1.0,
    "watthour": 3600,
    "kilowatthour": 3600000,
    "newtonmeter": 1.0,
    "calorie_nutr": 4186.8,
    "kilocalorie_nutr": 4186800.00,
    "electronvolt": 1.602176634e-19,
    "britishthermalunit_it": 1055.05585,
    "footpound": 1.35_58_18,
}




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase				):


   """simple docstring"""




   if to_type not in ENERGY_CONVERSION or from_type not in ENERGY_CONVERSION:
      lowercase_						:     Union[str, Any]							     =  (
          F"""Incorrect 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"""
          F"""Valid values are: {", ".join(_UpperCamelCase				)}"""
      )
      raise ValueError(_UpperCamelCase				)
   return value * ENERGY_CONVERSION[from_type] / ENERGY_CONVERSION[to_type]


if __name__ == "__main__":
 import doctest

 doctest.testmod()




