






from ..utils import DummyObject, requires_backends






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Dict ,					*__UpperCAmelCase      :						Any ,					**__UpperCAmelCase      :						List[Any]  )    ->Tuple:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						List[Any] ,					*__UpperCAmelCase      :						Dict ,					**__UpperCAmelCase      :						Optional[Any]  )    ->Tuple:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Union[str, Any] ,					*__UpperCAmelCase      :						int ,					**__UpperCAmelCase      :						int  )    ->int:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Dict ,					*__UpperCAmelCase      :						Optional[int] ,					**__UpperCAmelCase      :						str  )    ->List[str]:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						List[str] ,					*__UpperCAmelCase      :						Dict ,					**__UpperCAmelCase      :						Optional[Any]  )    ->Tuple:




       """simple docstring"""


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







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




       """simple docstring"""


       requires_backends(cls ,					['''torch''']  )
def 						_a    (      *a :Union[str, Any]	,							**a :List[str] )							->			int:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :Dict	,							**a :Dict )							->			List[str]:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :Dict	,							**a :Any )							->			Tuple:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :Any	,							**a :Union[str, Any] )							->			List[Any]:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :List[str]	,							**a :Dict )							->			Optional[int]:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :Any	,							**a :Union[str, Any] )							->			Any:
 requires_backends(a	,							['''torch'''] )
def 						_a    (      *a :List[Any]	,							**a :Any )							->			int:
 requires_backends(a	,							['''torch'''] )






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[Any] ,					*__UpperCAmelCase      :						List[Any] ,					**__UpperCAmelCase      :						List[str]  )    ->Tuple:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[int] ,					*__UpperCAmelCase      :						Dict ,					**__UpperCAmelCase      :						List[str]  )    ->Optional[int]:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Tuple ,					*__UpperCAmelCase      :						Any ,					**__UpperCAmelCase      :						Tuple  )    ->str:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[Any] ,					*__UpperCAmelCase      :						str ,					**__UpperCAmelCase      :						str  )    ->Any:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						int ,					*__UpperCAmelCase      :						str ,					**__UpperCAmelCase      :						int  )    ->Dict:




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Union[str, Any] ,					*__UpperCAmelCase      :						str ,					**__UpperCAmelCase      :						Any  )    ->Tuple:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						List[Any] ,					*__UpperCAmelCase      :						List[Any] ,					**__UpperCAmelCase      :						int  )    ->Dict:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[Any] ,					*__UpperCAmelCase      :						Any ,					**__UpperCAmelCase      :						Any  )    ->List[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						List[str] ,					*__UpperCAmelCase      :						Optional[int] ,					**__UpperCAmelCase      :						str  )    ->Dict:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Tuple ,					*__UpperCAmelCase      :						Any ,					**__UpperCAmelCase      :						Dict  )    ->str:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







      def __init__(      self      :						Any ,					*__UpperCAmelCase      :						Tuple ,					**__UpperCAmelCase      :						Dict  )    ->Any:




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Dict ,					*__UpperCAmelCase      :						Union[str, Any] ,					**__UpperCAmelCase      :						str  )    ->Optional[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Any ,					*__UpperCAmelCase      :						Dict ,					**__UpperCAmelCase      :						Dict  )    ->Union[str, Any]:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						List[Any] ,					*__UpperCAmelCase      :						Optional[Any] ,					**__UpperCAmelCase      :						Dict  )    ->List[Any]:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Optional[Any] ,					*__UpperCAmelCase      :						Dict ,					**__UpperCAmelCase      :						Optional[Any]  )    ->str:




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Tuple ,					*__UpperCAmelCase      :						Any ,					**__UpperCAmelCase      :						str  )    ->Optional[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Dict ,					*__UpperCAmelCase      :						Optional[Any] ,					**__UpperCAmelCase      :						str  )    ->List[str]:




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


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






class 		lowercase_					(	metaclass=lowercase   ):






      '''simple docstring'''




      __snake_case       =  ['''torch''']







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




       """simple docstring"""


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







      @classmethod
      def       __lowerCAmelCase					(      cls      :						Tuple ,					*__UpperCAmelCase      :						int ,					**__UpperCAmelCase      :						Union[str, Any]  )    ->List[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


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










from math import factorial

UpperCAmelCase__				   =		{str(digit): factorial(digit) for digit in range(10)}
def 						_a    (      a :int )							->			int:
 if not isinstance(a	,							a ):
  raise TypeError('''Parameter number must be int''' )

 if number < 0:
  raise ValueError('''Parameter number must be greater than or equal to 0''' )

 # Converts number in string to iterate on its digits and adds its factorial.
 return sum(DIGIT_FACTORIAL[digit] for digit in str(a ) )
def 						_a    (      a :int = 60	,							a :int = 1_000_000 )							->			int:

 if not isinstance(a	,							a ) or not isinstance(a	,							a ):
  raise TypeError('''Parameters chain_length and number_limit must be int''' )

 if chain_length <= 0 or number_limit <= 0:
  raise ValueError(
      '''Parameters chain_length and number_limit must be greater than 0''' )

 # the counter for the chains with the exact desired length
 a		  =      0
 # the cached sizes of the previous chains
 a		  =      {}

 for start_chain_element in range(1	,							a ):
  # The temporary set will contain the elements of the chain
  a		  =      set()
  a		  =      0

  # Stop computing the chain when you find a cached size, a repeating item or the
  # length is greater then the desired one.
  a		  =      start_chain_element
  while (
      chain_element not in chain_sets_lengths
      and chain_element not in chain_set
      and chain_set_length <= chain_length
  ):
   chain_set.add(a )
   chain_set_length += 1
   a		  =      digit_factorial_sum(a )

  if chain_element in chain_sets_lengths:
   chain_set_length += chain_sets_lengths[chain_element]

  a		  =      chain_set_length

  # If chain contains the exact amount of elements increase the counter
  if chain_set_length == chain_length:
   chains_counter += 1

 return chains_counter


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(f"""{solution()}""")


