




from ..utils import DummyObject, requires_backends




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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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



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



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



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



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



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



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




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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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







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






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






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






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









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase	:						List[Any]			=     {
    "configuration_swinv2": ["SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP", "Swinv2Config"],
}


try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCAmelCase	:						Union[str, Any]			=     [
         "SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST",
         "Swinv2ForImageClassification",
         "Swinv2ForMaskedImageModeling",
         "Swinv2Model",
         "Swinv2PreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_swinva import (
              SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
              SwinvaForImageClassification,
              SwinvaForMaskedImageModeling,
              SwinvaModel,
              SwinvaPreTrainedModel,
          )


else:
     import sys

     _UpperCAmelCase	:						Tuple			=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



