



"""simple docstring"""





from ..utils import DummyObject, requires_backends
class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



       def __init__(							self      :  int		,    *_UpperCAmelCase      :  str		,    **_UpperCAmelCase      :  Any   )			->						int:


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  int		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  str   )			->						Tuple:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  Union[str, Any]		,    **_UpperCAmelCase      :  Dict   )			->						Optional[int]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  str		,    *_UpperCAmelCase      :  List[str]		,    **_UpperCAmelCase      :  Tuple   )			->						List[Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  List[Any]		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Tuple   )			->						str:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  str		,    *_UpperCAmelCase      :  Any		,    **_UpperCAmelCase      :  Tuple   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  List[Any]		,    *_UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  List[Any]   )			->						Optional[Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Tuple   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
def        a__     (				*lowerCAmelCase__     ,      **lowerCAmelCase__				):
      requires_backends(lowerCAmelCase__     ,      ["torch"]				)
class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Optional[Any]		,    *_UpperCAmelCase      :  Any		,    **_UpperCAmelCase      :  List[Any]   )			->						Tuple:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  str		,    *_UpperCAmelCase      :  int		,    **_UpperCAmelCase      :  int   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  str		,    **_UpperCAmelCase      :  int   )			->						int:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  Optional[Any]		,    **_UpperCAmelCase      :  Union[str, Any]   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Dict		,    *_UpperCAmelCase      :  str		,    **_UpperCAmelCase      :  Dict   )			->						int:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Dict		,    *_UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  List[str]   )			->						List[str]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  Optional[int]		,    *_UpperCAmelCase      :  List[str]		,    **_UpperCAmelCase      :  str   )			->						int:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Any		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Tuple   )			->						int:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  Any		,    **_UpperCAmelCase      :  Tuple   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Dict		,    *_UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  Union[str, Any]   )			->						Optional[int]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Dict		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Tuple   )			->						Dict:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  List[str]		,    *_UpperCAmelCase      :  List[Any]		,    **_UpperCAmelCase      :  Tuple   )			->						List[Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



       def __init__(							self      :  str		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Any   )			->						str:


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Optional[Any]		,    *_UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  List[Any]   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  str		,    *_UpperCAmelCase      :  str		,    **_UpperCAmelCase      :  Any   )			->						Tuple:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  str		,    *_UpperCAmelCase      :  str		,    **_UpperCAmelCase      :  List[str]   )			->						List[str]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  int		,    **_UpperCAmelCase      :  int   )			->						int:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  Optional[Any]		,    *_UpperCAmelCase      :  List[Any]		,    **_UpperCAmelCase      :  Tuple   )			->						Any:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  Tuple		,    *_UpperCAmelCase      :  int		,    **_UpperCAmelCase      :  int   )			->						Union[str, Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







       @classmethod
       def 					lowercase__    (							cls      :  List[Any]		,    *_UpperCAmelCase      :  Tuple		,    **_UpperCAmelCase      :  Optional[Any]   )			->						Optional[Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )



class 				lowercase__       (   metaclass=SCREAMING_SNAKE_CASE				):







       '''simple docstring'''


       UpperCamelCase						=					['''torch''']



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


             '''simple docstring'''




             requires_backends(self		,    ["torch"]   )



       @classmethod
       def 					lowercase__    (							cls      :  Any		,    *_UpperCAmelCase      :  Dict		,    **_UpperCAmelCase      :  Dict   )			->						List[Any]:


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )







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


             '''simple docstring'''




             requires_backends(cls		,    ["torch"]   )









"""simple docstring"""





def        a__     (				lowerCAmelCase__ = 2000000				):
      UpperCAmelCase_      			=							[0 for i in range(n + 1				)]
      UpperCAmelCase_      			=							1
      UpperCAmelCase_      			=							1

      for i in range(2     ,      int(n**0.5				) + 1				):
            if primality_list[i] == 0:
                  for j in range(i * i     ,      n + 1     ,      lowerCAmelCase__				):
                        UpperCAmelCase_      			=							1
      UpperCAmelCase_      			=							0
      for i in range(lowerCAmelCase__				):
            if primality_list[i] == 0:
                  sum_of_primes += i
      return sum_of_primes


if __name__ == "__main__":
  print(F"{solution() = }")




