from ..utils import DummyObject, requires_backends


class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       int								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       int								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							Optional[int]      , **UpperCAmelCase__     :							List[str]  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							Optional[Any]      , **UpperCAmelCase__     :							Any  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							str      , **UpperCAmelCase__     :							Union[str, Any]  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							Tuple      , **UpperCAmelCase__     :							str  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							Tuple      , **UpperCAmelCase__     :							str  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							Optional[int]      , **UpperCAmelCase__     :							List[str]  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )





def 	__lowerCamelCase							(*UpperCAmelCase__     :							List[str]      , **UpperCAmelCase__     :							Optional[int]  ):
					requires_backends(UpperCAmelCase__      , ["torch"]  )


class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       int								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




							@classmethod
							def 	__snake_case(						cls   :					Optional[Any]	,							*_UpperCamelCase   :					List[str]	,							**_UpperCamelCase   :					Tuple      )					->				Union[str, Any]:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





							@classmethod
							def 	__snake_case(						cls   :					str	,							*_UpperCamelCase   :					int	,							**_UpperCamelCase   :					Any      )					->				int:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Dict								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





							@classmethod
							def 	__snake_case(						cls   :					int	,							*_UpperCamelCase   :					Any	,							**_UpperCamelCase   :					Tuple      )					->				str:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





							@classmethod
							def 	__snake_case(						cls   :					Tuple	,							*_UpperCamelCase   :					Tuple	,							**_UpperCamelCase   :					Any      )					->				int:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Dict								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




							@classmethod
							def 	__snake_case(						cls   :					int	,							*_UpperCamelCase   :					Optional[int]	,							**_UpperCamelCase   :					Dict      )					->				int:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Union[str, Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[str]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Any								=							["""torch"""]




							def __init__(						self   :					str	,							*_UpperCamelCase   :					str	,							**_UpperCamelCase   :					int      )					->				Tuple:



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       List[Any]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




							@classmethod
							def 	__snake_case(						cls   :					Any	,							*_UpperCamelCase   :					int	,							**_UpperCamelCase   :					Tuple      )					->				Tuple:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





							@classmethod
							def 	__snake_case(						cls   :					int	,							*_UpperCamelCase   :					str	,							**_UpperCamelCase   :					int      )					->				Any:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Dict								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Tuple								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





							@classmethod
							def 	__snake_case(						cls   :					int	,							*_UpperCamelCase   :					List[Any]	,							**_UpperCamelCase   :					Any      )					->				List[Any]:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       int								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       int								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )



class 						lowercase    (     metaclass=a     ):
							lowercase__						:       Optional[int]								=							["""torch"""]




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



												'''simple docstring'''

												requires_backends(self	,							["torch"]      )




							@classmethod
							def 	__snake_case(						cls   :					Any	,							*_UpperCamelCase   :					List[Any]	,							**_UpperCamelCase   :					List[Any]      )					->				Any:



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





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



												'''simple docstring'''

												requires_backends(cls	,							["torch"]      )





def 	__lowerCamelCase							(UpperCAmelCase__     :							list[int]  ):
					if not numbers:
										return 0

					if not isinstance(UpperCAmelCase__      , (list, tuple)  ) or not all(
					    isinstance(UpperCAmelCase__      , UpperCAmelCase__  ) for number in numbers  ):
										raise ValueError("numbers must be an iterable of integers"  )

					SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       numbers[0]

					for i in range(1      , len(UpperCAmelCase__  )  ):
										# update the maximum and minimum subarray products
										SCREAMING_SNAKE_CASE    			=       numbers[i]
										if number < 0:
															SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       min_till_now, max_till_now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , max_till_now * number  )
										SCREAMING_SNAKE_CASE    			=       min(UpperCAmelCase__      , min_till_now * number  )

										# update the maximum product found till now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , UpperCAmelCase__  )

					return max_prod




