



"""simple docstring"""


from ..utils import DummyObject, requires_backends







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Any   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[int]					)				->			Optional[int]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :List[str]   ,  **lowercase_ :str					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Optional[int]					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Union[str, Any]   ,  *lowercase_ :Tuple   ,  **lowercase_ :List[str]					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :int   ,  **lowercase_ :Dict					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :List[str]					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Any   ,  *lowercase_ :Any   ,  **lowercase_ :Tuple					)				->			Union[str, Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :int   ,  **lowercase_ :Union[str, Any]					)				->			int:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Optional[int]					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Union[str, Any]   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[int]					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :List[str]   ,  **lowercase_ :List[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :Tuple   ,  **lowercase_ :Optional[Any]					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[Any]   ,  *lowercase_ :List[str]   ,  **lowercase_ :Tuple					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Any					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Tuple   ,  **lowercase_ :List[str]					)				->			int:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :str   ,  *lowercase_ :Any   ,  **lowercase_ :Dict					)				->			int:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :int   ,  **lowercase_ :List[str]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Dict					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :int					)				->			int:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :str   ,  **lowercase_ :Any					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :int   ,  **lowercase_ :Optional[Any]					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :Any   ,  **lowercase_ :Optional[int]					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :str					)				->			Any:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :int   ,  **lowercase_ :Optional[int]					)				->			Any:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :Tuple   ,  **lowercase_ :List[Any]					)				->			Optional[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :List[Any]   ,  **lowercase_ :int					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :int   ,  **lowercase_ :int					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Tuple					)				->			str:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :int   ,  **lowercase_ :Union[str, Any]					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :Any   ,  **lowercase_ :Optional[Any]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Union[str, Any]					)				->			Union[str, Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :int   ,  **lowercase_ :List[Any]					)				->			int:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Any   ,  **lowercase_ :int					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)


def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)

def  _lowerCAmelCase      (   *lowercase_		,	**lowercase_						):
						requires_backends(lowercase_		,	['torch']						)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :List[Any]					)				->			Dict:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Tuple   ,  **lowercase_ :List[str]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[Any]					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :List[str]   ,  **lowercase_ :Dict					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :Any   ,  **lowercase_ :List[Any]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :str					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Dict   ,  *lowercase_ :int   ,  **lowercase_ :Tuple					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :str   ,  **lowercase_ :Tuple					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :str   ,  **lowercase_ :str					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Any   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Union[str, Any]					)				->			int:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :str   ,  **lowercase_ :List[Any]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[int]					)				->			int:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[int]   ,  *lowercase_ :Dict   ,  **lowercase_ :str					)				->			Union[str, Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Any   ,  **lowercase_ :str					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :str					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Union[str, Any]   ,  *lowercase_ :str   ,  **lowercase_ :Optional[int]					)				->			str:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :List[str]   ,  **lowercase_ :List[Any]					)				->			Any:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :str   ,  **lowercase_ :Optional[int]					)				->			Any:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[int]   ,  *lowercase_ :Any   ,  **lowercase_ :Any					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :int   ,  **lowercase_ :Optional[int]					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :int					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :int   ,  **lowercase_ :Any					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Dict					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[Any]					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Tuple					)				->			Dict:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Tuple   ,  **lowercase_ :Any					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :int					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :str   ,  **lowercase_ :Optional[int]					)				->			str:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Tuple   ,  **lowercase_ :Tuple					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Union[str, Any]					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Dict   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Dict					)				->			Dict:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :List[str]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :Tuple   ,  **lowercase_ :Any					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[Any]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :List[str]					)				->			str:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :List[str]   ,  **lowercase_ :Dict					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Dict					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :str   ,  **lowercase_ :Any					)				->			Optional[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :str   ,  **lowercase_ :str					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :int   ,  **lowercase_ :Tuple					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Union[str, Any]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :int					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[int]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Optional[int]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :str   ,  **lowercase_ :Dict					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :List[Any]   ,  **lowercase_ :List[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Any					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :Dict   ,  **lowercase_ :str					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :Any   ,  **lowercase_ :Dict					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :int   ,  **lowercase_ :Dict					)				->			int:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :List[str]   ,  **lowercase_ :Any					)				->			int:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :Any   ,  **lowercase_ :Optional[int]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :List[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[Any]   ,  *lowercase_ :int   ,  **lowercase_ :Any					)				->			int:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Optional[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[int]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :Any   ,  **lowercase_ :List[Any]					)				->			str:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Union[str, Any]					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Optional[Any]					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :str   ,  **lowercase_ :List[str]					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Any   ,  **lowercase_ :Union[str, Any]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :List[Any]					)				->			Optional[int]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[int]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Union[str, Any]					)				->			Optional[int]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[int]   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[Any]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Dict					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :int   ,  *lowercase_ :Any   ,  **lowercase_ :List[str]					)				->			Optional[int]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :List[Any]   ,  **lowercase_ :List[str]					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :List[str]					)				->			int:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :List[str]					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[Any]					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Union[str, Any]					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Any   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :List[str]					)				->			Union[str, Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :int   ,  **lowercase_ :List[str]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :List[str]					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :List[str]   ,  **lowercase_ :int					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :str   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :str   ,  **lowercase_ :str					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :int   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :str   ,  **lowercase_ :Optional[Any]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :List[Any]					)				->			Dict:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Optional[Any]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :List[str]   ,  **lowercase_ :Any					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Any					)				->			int:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Dict   ,  *lowercase_ :str   ,  **lowercase_ :List[str]					)				->			Dict:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :List[str]   ,  **lowercase_ :List[str]					)				->			str:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :List[str]   ,  **lowercase_ :Union[str, Any]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :int   ,  *lowercase_ :List[str]   ,  **lowercase_ :Optional[Any]					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Tuple					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :str   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Optional[Any]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[Any]   ,  *lowercase_ :List[str]   ,  **lowercase_ :List[str]					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[Any]					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Any   ,  **lowercase_ :str					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Union[str, Any]					)				->			List[str]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :int   ,  **lowercase_ :int					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Union[str, Any]					)				->			Any:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Dict   ,  *lowercase_ :int   ,  **lowercase_ :List[Any]					)				->			Any:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :str   ,  **lowercase_ :Any					)				->			Any:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Union[str, Any]   ,  *lowercase_ :List[Any]   ,  **lowercase_ :List[Any]					)				->			Optional[Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :str   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Dict					)				->			Tuple:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[str]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Optional[Any]					)				->			Dict:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Tuple   ,  **lowercase_ :Optional[int]					)				->			Union[str, Any]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Optional[Any]   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Optional[Any]					)				->			Optional[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :str					)				->			int:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[int]					)				->			Any:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :Tuple   ,  *lowercase_ :List[Any]   ,  **lowercase_ :Optional[Any]					)				->			Union[str, Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Optional[int]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :Optional[int]   ,  **lowercase_ :Any					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[str]   ,  *lowercase_ :str   ,  **lowercase_ :Optional[Any]					)				->			Optional[int]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :int   ,  *lowercase_ :Dict   ,  **lowercase_ :Dict					)				->			List[Any]:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Tuple   ,  *lowercase_ :Union[str, Any]   ,  **lowercase_ :Optional[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :str   ,  *lowercase_ :Dict   ,  **lowercase_ :Optional[int]					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Any   ,  *lowercase_ :Dict   ,  **lowercase_ :List[str]					)				->			int:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :List[Any]   ,  *lowercase_ :Optional[Any]   ,  **lowercase_ :Optional[int]					)				->			str:
												requires_backends(cls   ,  ['torch']					)







class       A_			(     metaclass=SCREAMING_SNAKE_CASE_				):



						"""simple docstring"""
						__UpperCamelCase						=							["""torch"""]






						def __init__(					self :List[Any]   ,  *lowercase_ :Dict   ,  **lowercase_ :Union[str, Any]					)				->			List[Any]:
												requires_backends(self   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Dict   ,  *lowercase_ :int   ,  **lowercase_ :Optional[Any]					)				->			Tuple:
												requires_backends(cls   ,  ['torch']					)






						@classmethod
						def 	UpperCAmelCase__     (					cls :Optional[Any]   ,  *lowercase_ :str   ,  **lowercase_ :Tuple					)				->			List[str]:
												requires_backends(cls   ,  ['torch']					)










'''simple docstring'''




from __future__ import annotations


def 				lowerCAmelCase_   (	_lowerCamelCase:   list[int]					):
		if not nums:
				return 0
		__SCREAMING_SNAKE_CASE       :		Optional[int]           =		nums[0]
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		0
		for num in nums[1:]:
				__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       :		Any           =		(
				    max_excluding + num,
				    max(_lowerCamelCase       ,      _lowerCamelCase					),
				)
		return max(_lowerCamelCase       ,      _lowerCamelCase					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()