




"""simple docstring"""







from ..utils import DummyObject, requires_backends






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			List[Any]						,						*lowerCAmelCase				:			Optional[Any]						,						**lowerCAmelCase				:			Tuple					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			Tuple						,						*lowerCAmelCase				:			List[str]						,						**lowerCAmelCase				:			Any					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


						@classmethod
						def   __lowercase (							cls				:			Dict						,						*lowerCAmelCase				:			int						,						**lowerCAmelCase				:			Any					):
										requires_backends(cls						,						["""torch"""]					)




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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





def 							lowercase					(*snake_case__   : List[Any]      ,       **snake_case__   : Tuple )     ->  Tuple:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : Optional[Any]      ,       **snake_case__   : List[str] )     ->  Union[str, Any]:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : str      ,       **snake_case__   : List[Any] )     ->  str:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : Union[str, Any]      ,       **snake_case__   : Optional[Any] )     ->  Tuple:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : str      ,       **snake_case__   : List[str] )     ->  Tuple:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : List[Any]      ,       **snake_case__   : Dict )     ->  Union[str, Any]:


				'''simple docstring'''






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





def 							lowercase					(*snake_case__   : Tuple      ,       **snake_case__   : List[Any] )     ->  Any:


				'''simple docstring'''






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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			str						,						*lowerCAmelCase				:			List[Any]						,						**lowerCAmelCase				:			Tuple					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


						@classmethod
						def   __lowercase (							cls				:			Tuple						,						*lowerCAmelCase				:			Any						,						**lowerCAmelCase				:			Tuple					):
										requires_backends(cls						,						["""torch"""]					)




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			Any						,						*lowerCAmelCase				:			Any						,						**lowerCAmelCase				:			Any					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			List[Any]						,						*lowerCAmelCase				:			Tuple						,						**lowerCAmelCase				:			Tuple					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




						@classmethod
						def   __lowercase (							cls				:			Dict						,						*lowerCAmelCase				:			str						,						**lowerCAmelCase				:			List[str]					):
										requires_backends(cls						,						["""torch"""]					)






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


						@classmethod
						def   __lowercase (							cls				:			List[Any]						,						*lowerCAmelCase				:			List[Any]						,						**lowerCAmelCase				:			Tuple					):
										requires_backends(cls						,						["""torch"""]					)




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


						@classmethod
						def   __lowercase (							cls				:			int						,						*lowerCAmelCase				:			str						,						**lowerCAmelCase				:			int					):
										requires_backends(cls						,						["""torch"""]					)




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


						@classmethod
						def   __lowercase (							cls				:			Tuple						,						*lowerCAmelCase				:			List[str]						,						**lowerCAmelCase				:			List[Any]					):
										requires_backends(cls						,						["""torch"""]					)




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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






class       SCREAMING_SNAKE_CASE__					(					metaclass=_a					):
						_a    						=						['torch']


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


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




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











"""simple docstring"""







import argparse
from argparse import Namespace

import torch
from torch import nn

from transformers import XGLMConfig, XGLMForCausalLM





def 							lowercase					(snake_case__   : Union[str, Any] )     ->  List[str]:


				'''simple docstring'''






				lowerCAmelCase  =				[
				    """decoder.version""",
				    """decoder.output_projection.weight""",
				    """_float_tensor""",
				    """decoder.embed_positions._float_tensor""",
				]
				for k in ignore_keys:
								state_dict.pop(snake_case__      ,       snake_case__ )





def 							lowercase					(snake_case__   : List[str] )     ->  Optional[int]:


				'''simple docstring'''






				lowerCAmelCase ,						lowerCAmelCase  =				emb.weight.shape
				lowerCAmelCase  =				nn.Linear(snake_case__      ,       snake_case__      ,       bias=snake_case__ )
				lowerCAmelCase  =				emb.weight.data
				return lin_layer





def 							lowercase					(snake_case__   : str )     ->  Optional[Any]:


				'''simple docstring'''






				lowerCAmelCase  =				torch.load(snake_case__      ,       map_location="""cpu""" )
				lowerCAmelCase  =				Namespace(**checkpoint["""cfg"""]["""model"""] )
				lowerCAmelCase  =				checkpoint["""model"""]
				remove_ignore_keys_(snake_case__ )
				lowerCAmelCase  =				state_dict["""decoder.embed_tokens.weight"""].shape[0]

				lowerCAmelCase  =				{key.replace("""decoder"""      ,       """model""" ): val for key, val in state_dict.items()}

				lowerCAmelCase  =				XGLMConfig(
				    vocab_size=snake_case__      ,       max_position_embeddings=args.max_target_positions      ,       num_layers=args.decoder_layers      ,       attention_heads=args.decoder_attention_heads      ,       ffn_dim=args.decoder_ffn_embed_dim      ,       d_model=args.decoder_embed_dim      ,       layerdrop=args.decoder_layerdrop      ,       dropout=args.dropout      ,       attention_dropout=args.attention_dropout      ,       activation_dropout=args.activation_dropout      ,       activation_function="""gelu"""      ,       scale_embedding=not args.no_scale_embedding      ,       tie_word_embeddings=args.share_decoder_input_output_embed      ,       )

				lowerCAmelCase  =				XGLMForCausalLM(snake_case__ )
				lowerCAmelCase  =				model.load_state_dict(snake_case__      ,       strict=snake_case__ )
				print(snake_case__ )
				lowerCAmelCase  =				make_linear_from_emb(model.model.embed_tokens )

				return model


if __name__ == "__main__":
		a      =							argparse.ArgumentParser()
		# Required parameters
		parser.add_argument('fairseq_path', type=str, help='path to a model.pt on local filesystem.')
		parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
		a      =							parser.parse_args()
		a      =							convert_fairseq_xglm_checkpoint_from_disk(args.fairseq_path)
		model.save_pretrained(args.pytorch_dump_folder_path)





