





from ..utils import DummyObject, requires_backends

class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Optional[Any]       ,      *UpperCAmelCase						: Optional[Any]       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: Optional[Any]       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: Optional[Any]       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: List[str]      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Tuple   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Union[str, Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: List[Any]       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Tuple   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[Any]   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: Union[str, Any]       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Dict   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: Optional[Any]       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: Optional[int]       ,      *UpperCAmelCase						: Tuple       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[str]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: Union[str, Any]       ,      **UpperCAmelCase						: Union[str, Any]      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Optional[int]       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Union[str, Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: str      ):
           requires_backends(cls       ,      ["""torch"""]      )






def       __UpperCamelCase					(      *lowercase__						:							Tuple		,     **lowercase__						:							Dict		)						->   Tuple:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Tuple		,     **lowercase__						:							int		)						->   Union[str, Any]:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Any		,     **lowercase__						:							Tuple		)						->   int:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Tuple		,     **lowercase__						:							List[str]		)						->   Dict:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Union[str, Any]		,     **lowercase__						:							Union[str, Any]		)						->   Optional[Any]:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Optional[int]		,     **lowercase__						:							Tuple		)						->   Optional[Any]:
    '''simple docstring'''





    requires_backends(_snake_case		,     ["""torch"""]		)
def       __UpperCamelCase					(      *lowercase__						:							Tuple		,     **lowercase__						:							Union[str, Any]		)						->   Optional[Any]:
    '''simple docstring'''





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

class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[str]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Tuple       ,      *UpperCAmelCase						: str       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Optional[Any]       ,      *UpperCAmelCase						: List[Any]       ,      **UpperCAmelCase						: Optional[Any]      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Any       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: Any      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[str]   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: Optional[int]      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: List[Any]       ,      **UpperCAmelCase						: Optional[Any]      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Optional[int]       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: List[Any]       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : str   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: List[str]       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[str]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Dict   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: List[str]       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Dict       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : str   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Tuple       ,      *UpperCAmelCase						: str       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Union[str, Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: List[str]       ,      *UpperCAmelCase						: Optional[Any]       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: List[str]       ,      *UpperCAmelCase						: Optional[Any]       ,      **UpperCAmelCase						: Dict      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Tuple   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[int]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : str   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: Tuple       ,      **UpperCAmelCase						: List[Any]      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Optional[Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Dict   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: List[Any]       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: Tuple       ,      *UpperCAmelCase						: int       ,      **UpperCAmelCase						: Tuple      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Union[str, Any]   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : int   =		["""torch"""]



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



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



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[str]   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Union[str, Any]       ,      *UpperCAmelCase						: str       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: Tuple       ,      *UpperCAmelCase						: Optional[int]       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Any   =		["""torch"""]



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



       @classmethod
       def 			A				(  cls						: Any       ,      *UpperCAmelCase						: Dict       ,      **UpperCAmelCase						: Any      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : Union[str, Any]   =		["""torch"""]



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



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



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: Union[str, Any]       ,      **UpperCAmelCase						: int      ):
           requires_backends(cls       ,      ["""torch"""]      )






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : str   =		["""torch"""]



       def __init__(  self						: int       ,      *UpperCAmelCase						: str       ,      **UpperCAmelCase						: int      ):
           requires_backends(self       ,      ["""torch"""]      )



       @classmethod
       def 			A				(  cls						: int       ,      *UpperCAmelCase						: Union[str, Any]       ,      **UpperCAmelCase						: Union[str, Any]      ):
           requires_backends(cls       ,      ["""torch"""]      )



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






class 		__a				(						metaclass=__UpperCamelCase   ):
       __snake_case    : List[Any]   =		["""torch"""]



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



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



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




"""simple docstring"""



UpperCamelCase__          =	{
    'meter': 'm',
    'kilometer': 'km',
    'megametre': 'Mm',
    'gigametre': 'Gm',
    'terametre': 'Tm',
    'petametre': 'Pm',
    'exametre': 'Em',
    'zettametre': 'Zm',
    'yottametre': 'Ym',
}
# Exponent of the factor(meter)
UpperCamelCase__          =	{
    'm': 0,
    'km': 3,
    'Mm': 6,
    'Gm': 9,
    'Tm': 12,
    'Pm': 15,
    'Em': 18,
    'Zm': 21,
    'Ym': 24,
}
def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case ):
    UpperCAmelCase__	:      int     							=					from_type.lower().strip('s' )
    UpperCAmelCase__	:      List[Any]     							=					to_type.lower().strip('s' )

    UpperCAmelCase__	:      Optional[int]     							=					UNIT_SYMBOL.get(_snake_case    ,_snake_case )
    UpperCAmelCase__	:      Optional[Any]     							=					UNIT_SYMBOL.get(_snake_case    ,_snake_case )

    if from_sanitized not in METRIC_CONVERSION:
        UpperCAmelCase__	:      Optional[int]     							=					(
            F'''Invalid \'from_type\' value: {from_type!r}.\n'''
            F'''Conversion abbreviations are: {', '.join(_snake_case )}'''
        )
        raise ValueError(_snake_case )
    if to_sanitized not in METRIC_CONVERSION:
        UpperCAmelCase__	:      int     							=					(
            F'''Invalid \'to_type\' value: {to_type!r}.\n'''
            F'''Conversion abbreviations are: {', '.join(_snake_case )}'''
        )
        raise ValueError(_snake_case )
    UpperCAmelCase__	:      str     							=					METRIC_CONVERSION[from_sanitized]
    UpperCAmelCase__	:      Optional[int]     							=					METRIC_CONVERSION[to_sanitized]
    UpperCAmelCase__	:      int     							=					1

    if from_exponent > to_exponent:
        UpperCAmelCase__	:      List[str]     							=					from_exponent - to_exponent
    else:
        UpperCAmelCase__	:      int     							=					-(to_exponent - from_exponent)

    return value * pow(10    ,_snake_case )


if __name__ == "__main__":
    from doctest import testmod

    testmod()

