



'''simple docstring'''

from ..utils import DummyObject, requires_backends



class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




					def __init__(	self					:						Dict  ,	*UpperCamelCase_					:						Dict  ,	**UpperCamelCase_					:						Dict       )	->							Tuple:



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




					def __init__(	self					:						Dict  ,	*UpperCamelCase_					:						Tuple  ,	**UpperCamelCase_					:						Tuple       )	->							Dict:



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )






class 		lowerCamelCase__   (    metaclass=A  ):




					'''simple docstring'''



					A_         =    ["""vision"""]




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



						'''simple docstring'''





						requires_backends(self  ,	['vision']       )





'''simple docstring'''

def     __UpperCamelCase					(				_lowercase = 1000       )			->      int:
	_lowercase       :							Dict  	=		0
	_lowercase       :							int  	=		0
	while 1:
		num += 3
		if num >= n:
			break
		total += num
		num += 2
		if num >= n:
			break
		total += num
		num += 1
		if num >= n:
			break
		total += num
		num += 3
		if num >= n:
			break
		total += num
		num += 1
		if num >= n:
			break
		total += num
		num += 2
		if num >= n:
			break
		total += num
		num += 3
		if num >= n:
			break
		total += num
	return total


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