"""simple docstring"""





from ..utils import DummyObject, requires_backends
class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			str							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Tuple							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			int    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			str    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Tuple							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			str    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )


def    lowercase_   (   *_lowerCamelCase:	Optional[int]						,   **_lowerCamelCase:	int      ) ->      List[Any]:



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


def    lowercase_   (   *_lowerCamelCase:	Optional[int]						,   **_lowerCamelCase:	Dict      ) ->      Tuple:



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


def    lowercase_   (   *_lowerCamelCase:	Optional[Any]						,   **_lowerCamelCase:	List[str]      ) ->      Dict:



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


def    lowercase_   (   *_lowerCamelCase:	int						,   **_lowerCamelCase:	List[Any]      ) ->      str:



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


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



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


def    lowercase_   (   *_lowerCamelCase:	int						,   **_lowerCamelCase:	str      ) ->      List[str]:



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )


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



							'''simple docstring'''

							requires_backends(_lowerCamelCase						,   ["torch"]      )
class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			str    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[int]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[str]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Dict							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Dict							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			str    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			str							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			str							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Dict							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			str    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			str    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Any    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			int							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			str							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			List[Any]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Any							,					*UpperCAmelCase      :			Optional[Any]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[int]							,					*UpperCAmelCase      :			str							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Dict							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Dict							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			str    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[int]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Optional[int]							,					**UpperCAmelCase      :			Any    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Optional[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			str    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			List[Any]							,					**UpperCAmelCase      :			Tuple    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			Union[str, Any]							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			int    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[Any]							,					*UpperCAmelCase      :			Any							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Any							,					*UpperCAmelCase      :			Tuple							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			Union[str, Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			str    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Tuple							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			Union[str, Any]    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			Union[str, Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			str    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			str							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			Optional[Any]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			Optional[Any]							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			int    ):
													requires_backends(cls							,					["torch"]    )

class  _snake_case     (					metaclass=a__		):
						snake_case__			  =			["torch"]






						def __init__(       self      :			int							,					*UpperCAmelCase      :			int							,					**UpperCAmelCase      :			List[Any]    ):
													requires_backends(self							,					["torch"]    )






						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			List[str]    ):
													requires_backends(cls							,					["torch"]    )







						@classmethod
						def       lowerCamelCase__     (       cls      :			List[str]							,					*UpperCAmelCase      :			Dict							,					**UpperCAmelCase      :			Optional[int]    ):
													requires_backends(cls							,					["torch"]    )
"""simple docstring"""





import gc
import threading
import time

import psutil
import torch
class  _snake_case     :






						def __init__(       self      :			str    ):
													__lowerCamelCase					:		Optional[Any]		   =     psutil.Process()
													__lowerCamelCase					:		List[Any]		   =     False






						def       lowerCamelCase__     (       self      :			str    ):
													__lowerCamelCase					:		List[Any]		   =     -1

													while True:
																				__lowerCamelCase					:		Union[str, Any]		   =     max(self.process.memory_info().rss							,					self.cpu_memory_peak    )

																				# can't sleep or will not catch the peak right (this comment is here on purpose)
																				if not self.peak_monitoring:
																											break






						def       lowerCamelCase__     (       self      :			Any    ):
													__lowerCamelCase					:		Optional[Any]		   =     True
													__lowerCamelCase					:		Union[str, Any]		   =     threading.Thread(target=self.peak_monitor    )
													__lowerCamelCase					:		Optional[Any]		   =     True
													self.thread.start()







						def       lowerCamelCase__     (       self      :			Dict    ):
													__lowerCamelCase					:		str		   =     False
													self.thread.join()
													return self.cpu_memory_peak

__A  =				PeakCPUMemory()


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



							'''simple docstring'''

							__lowerCamelCase					:		Any		   =     {"time": time.time()}

							gc.collect()
							torch.cuda.empty_cache()

							# CPU mem
							__lowerCamelCase					:		Optional[int]		   =     psutil.Process().memory_info().rss
							cpu_peak_tracker.start()

							# GPU mem
							for i in range(torch.cuda.device_count()      ):
														__lowerCamelCase					:		int		   =     torch.cuda.memory_allocated(_lowerCamelCase      )
							torch.cuda.reset_peak_memory_stats()

							return measures


def    lowercase_   (   _lowerCamelCase:	Optional[Any]      ) ->      Tuple:



							'''simple docstring'''

							__lowerCamelCase					:		Tuple		   =     {"time": time.time() - start_measures["time"]}

							gc.collect()
							torch.cuda.empty_cache()

							# CPU mem
							__lowerCamelCase					:		Dict		   =     (psutil.Process().memory_info().rss - start_measures["cpu"]) / 2**20
							__lowerCamelCase					:		Tuple		   =     (cpu_peak_tracker.stop() - start_measures["cpu"]) / 2**20

							# GPU mem
							for i in range(torch.cuda.device_count()      ):
														__lowerCamelCase					:		Any		   =     (torch.cuda.memory_allocated(_lowerCamelCase      ) - start_measures[str(_lowerCamelCase      )]) / 2**20
														__lowerCamelCase					:		Optional[int]		   =     (torch.cuda.max_memory_allocated(_lowerCamelCase      ) - start_measures[str(_lowerCamelCase      )]) / 2**20

							return measures







def    lowercase_   (   _lowerCamelCase:	int						,   _lowerCamelCase:	List[Any]      ) ->      Optional[int]:



							'''simple docstring'''

							print(F"""{description}:"""      )
							print(F"""- Time: {measures["time"]:.2f}s"""      )
							for i in range(torch.cuda.device_count()      ):
														print(F"""- GPU {i} allocated: {measures[str(_lowerCamelCase      )]:.2f}MiB"""      )
														__lowerCamelCase					:		List[Any]		   =     measures[F"""{i}-peak"""]
														print(F"""- GPU {i} peak: {peak:.2f}MiB"""      )
							print(F"""- CPU RAM allocated: {measures["cpu"]:.2f}MiB"""      )
							print(F"""- CPU RAM peak: {measures["cpu-peak"]:.2f}MiB"""      )