




"""simple docstring"""





from ..utils import DummyObject, requires_backends



class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Dict   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Any   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      Optional[int]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      List[Any]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      Optional[int]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      Dict:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      Optional[int]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      List[Any]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)

def        _UpperCamelCase     (      *UpperCamelCase					,							**UpperCamelCase				)      ->      List[Any]:


			"""simple docstring"""
			requires_backends(UpperCamelCase					,							["torch"]				)



class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Tuple   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Tuple   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Union[str, Any]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Dict   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Tuple   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     int   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     int   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Any   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


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


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Any   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[str]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Dict   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Any   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Union[str, Any]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Optional[Any]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     int   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     List[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     str   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Tuple   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Any):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     List[str]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     List[str]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[int]   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Optional[Any]   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     Any   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     List[Any]   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Tuple   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Union[str, Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[int]   ,	*UpperCamelCase_   :     int   ,	**UpperCamelCase_   :     Union[str, Any]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Any   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[Any]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     str   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     Tuple):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Optional[Any]   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Optional[int]   ,	**UpperCamelCase_   :     Dict):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     List[Any]   ,	**UpperCamelCase_   :     int):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])






class   a__					(						metaclass=__magic_name__ ):
			lowercase_		=						["torch"]


			def __init__(   self   :     Tuple   ,	*UpperCamelCase_   :     Tuple   ,	**UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						requires_backends(self   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Dict   ,	*UpperCamelCase_   :     Dict   ,	**UpperCamelCase_   :     List[str]):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])


			@classmethod
			def    a_  (   cls   :     Union[str, Any]   ,	*UpperCamelCase_   :     Union[str, Any]   ,	**UpperCamelCase_   :     str):


						"""simple docstring"""




						requires_backends(cls   ,	["torch"])



"""simple docstring"""






def      UpperCAmelCase__			(							lowerCAmelCase__	:int = 5_0						)					->       int:
      '''simple docstring'''


      lowercase								=      [1] * (length + 1)

      for row_length in range(3   ,						length + 1						):
            for block_length in range(3   ,						row_length + 1						):
                  for block_start in range(row_length - block_length						):
                        ways_number[row_length] += ways_number[
                            row_length - block_start - block_length - 1
                        ]

                  ways_number[row_length] += 1

      return ways_number[length]


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



