






'''simple docstring'''



from ..utils import DummyObject, requires_backends
class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Dict		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[Any]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		int		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		Tuple		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		List[Any]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		str		)  ->  int:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Optional[int]		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Tuple		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[Any]     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		str		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Any		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		str     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Any		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Any		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		str		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Tuple     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Dict		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		str		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[int]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Dict		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Any		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		str		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		List[str]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Tuple     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Optional[int]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		int		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		List[Any]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		List[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		List[Any]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





def 							lowercase_				(    *__A :       List[Any]					,      **__A :       Tuple			)       ->      Dict:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Union[str, Any]					,      **__A :       Dict			)       ->      str:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Any					,      **__A :       Dict			)       ->      Any:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Dict					,      **__A :       Dict			)       ->      Tuple:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Tuple					,      **__A :       str			)       ->      Union[str, Any]:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Tuple					,      **__A :       Optional[Any]			)       ->      Optional[Any]:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)


def 							lowercase_				(    *__A :       Any					,      **__A :       str			)       ->      Dict:



 """simple docstring"""




 requires_backends(__A					,      ['''torch''']			)
class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Tuple		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		int		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[str]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Dict		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		Any		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Union[str, Any]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		List[str]		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		int		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		int		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Any     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		str		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		int		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






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


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Any     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Tuple		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		str		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Any		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Any     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		str		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Any		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		int		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		int		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[Any]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		str		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		List[Any]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		int     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		int		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[str]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Any		)  ->  int:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		int		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[str]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		List[Any]		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		int		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Tuple     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		Tuple		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		str		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Any		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[Any]     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		Any		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		List[Any]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		int		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Tuple		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		int		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		List[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		int		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Union[str, Any]     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		List[Any]		)  ->  int:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		int		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Union[str, Any]     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		Dict		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		int		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Tuple		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Dict     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		List[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Dict		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Any     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Dict		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		int		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		List[str]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Dict		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		str		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		int		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Any		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		List[str]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		List[str]     ,      **UpperCAmelCase			:		Any		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Union[str, Any]		)  ->  Any:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Dict     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Tuple		)  ->  str:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Tuple     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		Any		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Optional[int]		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Optional[int]     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Any		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		str		)  ->  int:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Optional[int]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		int		)  ->  Dict:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		Dict     ,      **UpperCAmelCase			:		Tuple		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		str     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Dict     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		str		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[str]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Tuple		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		Tuple     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Optional[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		Dict		)  ->  List[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[Any]     ,      *UpperCAmelCase			:		int     ,      **UpperCAmelCase			:		Any		)  ->  Optional[Any]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[Any]     ,      *UpperCAmelCase			:		Optional[int]     ,      **UpperCAmelCase			:		Dict		)  ->  Any:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Optional[int]     ,      *UpperCAmelCase			:		List[Any]     ,      **UpperCAmelCase			:		str		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Any     ,      *UpperCAmelCase			:		str     ,      **UpperCAmelCase			:		List[Any]		)  ->  Dict:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






      def __init__( self			:		List[str]     ,      *UpperCAmelCase			:		Tuple     ,      **UpperCAmelCase			:		Tuple		)  ->  Union[str, Any]:


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		List[Any]     ,      *UpperCAmelCase			:		Any     ,      **UpperCAmelCase			:		Any		)  ->  List[str]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Dict     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		Dict		)  ->  Optional[int]:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)





class UpperCAmelCase_					(    metaclass=__A				):




      """simple docstring"""




      UpperCamelCase_								=			['''torch''']






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


       '''simple docstring'''

       requires_backends(self     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		int     ,      *UpperCAmelCase			:		Union[str, Any]     ,      **UpperCAmelCase			:		List[str]		)  ->  str:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)






      @classmethod
      def 				A__      ( cls			:		Union[str, Any]     ,      *UpperCAmelCase			:		Optional[Any]     ,      **UpperCAmelCase			:		Optional[int]		)  ->  Tuple:


       '''simple docstring'''

       requires_backends(cls     ,      ['''torch''']		)











'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


SCREAMING_SNAKE_CASE						=	{
    'configuration_mega': ['MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegaConfig', 'MegaOnnxConfig'],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE						=	[
          'MEGA_PRETRAINED_MODEL_ARCHIVE_LIST',
          'MegaForCausalLM',
          'MegaForMaskedLM',
          'MegaForMultipleChoice',
          'MegaForQuestionAnswering',
          'MegaForSequenceClassification',
          'MegaForTokenClassification',
          'MegaModel',
          'MegaPreTrainedModel',
      ]

if TYPE_CHECKING:
      from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mega import (
                MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
                MegaForCausalLM,
                MegaForMaskedLM,
                MegaForMultipleChoice,
                MegaForQuestionAnswering,
                MegaForSequenceClassification,
                MegaForTokenClassification,
                MegaModel,
                MegaPreTrainedModel,
            )

else:
      import sys

      SCREAMING_SNAKE_CASE						=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



