






from ..utils import DummyObject, requires_backends




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )




class        snake_case_					(						metaclass=__UpperCamelCase			):

						"""simple docstring"""



						snake_case__   					=			["""vision"""]



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




											'''simple docstring'''



											requires_backends(self   ,				["vision"]      )













def 						a_      (__A			)							->	list:



					"""simple docstring"""
					if len(__A			) <= 1:
										return data
					else:
										return [
										    *quick_sort([e for e in data[1:] if e <= data[0]]			),
										    data[0],
										    *quick_sort([e for e in data[1:] if e > data[0]]			),
										]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





