

'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )

def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			int:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			List[str]:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			int:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			str:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			int:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			Any:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)
def       UpperCAmelCase__    (      *UpperCAmelCase__,       **UpperCAmelCase__				)			->			Any:
       requires_backends(UpperCAmelCase__,       ["""torch"""]				)


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[Any]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      str:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Tuple:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      List[str]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







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





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )


class 					A__      (      metaclass=_snake_case			):
    lowercase						=		["torch"]



    def __init__(					self		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Optional[int]:





           '''simple docstring'''
           requires_backends(self		,				["""torch"""]       )



    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )







    @classmethod
    def 					snake_case_			(					cls		,				*UpperCamelCase__		,				**UpperCamelCase__       )						->      int:





           '''simple docstring'''
           requires_backends(cls		,				["""torch"""]       )



'''simple docstring'''







import warnings

from diffusers import StableDiffusionImgaImgPipeline  # noqa F401


warnings.warn(
    '''The `image_to_image.py` script is outdated. Please use directly `from diffusers import'''
    ''' StableDiffusionImg2ImgPipeline` instead.'''
)
