


'''simple docstring'''
lowerCAmelCase__  =     {
    0: 'underwear',
    1: 'pants',
    2: 'belt',
    3: 'suit',
    4: 'shoe',
    5: 'socks',
    6: 'shirt',
    7: 'tie',
    8: 'watch',
}

lowerCAmelCase__  =     [[1, 4], [2, 4], [3], [], [], [4], [2, 7], [3], []]

lowerCAmelCase__  =     [0 for x in range(len(graph))]
lowerCAmelCase__  =     []



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	str          =					1
       while stack:
              snake_case__					:	List[Any]          =					stack.pop()
              print(UpperCAmelCase    ,       clothes[current_clothing]     )
              order += 1



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	str          =					1
       for v in graph[u]:
              if not visited[v]:
                     depth_first_search(UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     )

       stack.append(UpperCAmelCase     )



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       for v in range(len(UpperCAmelCase     )     ):
              if not visited[v]:
                     depth_first_search(UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     )


if __name__ == "__main__":
     topological_sort(graph, visited)
     print(stack)
     print_stack(stack, clothes)








'''simple docstring'''
from ..utils import DummyObject, requires_backends







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					str						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Dict						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Dict						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					int						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Tuple						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					List[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Union[str, Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Tuple						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Any					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					str						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					Union[str, Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Optional[int]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Optional[Any]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					int						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Any						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					str					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					str						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					int						)->	Union[str, Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					Optional[Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					int						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[Any]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Union[str, Any]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					int					, **lowerCamelCase	:					Dict						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					int						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					Optional[int]						)->	List[str]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Union[str, Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Tuple						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Optional[Any]						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Any						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Union[str, Any]						)->	Any:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[Any]					, **lowerCamelCase	:					Optional[int]						)->	List[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					str					, **lowerCamelCase	:					Tuple						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Tuple					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[Any]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Dict					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					List[Any]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Union[str, Any]						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Union[str, Any]					, **lowerCamelCase	:					List[str]						)->	Optional[Any]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Tuple					, **lowerCamelCase	:					Optional[int]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					int					, *lowerCamelCase	:					List[Any]					, **lowerCamelCase	:					Dict						)->	Optional[int]:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					str					, *lowerCamelCase	:					Any					, **lowerCamelCase	:					Optional[int]						)->	int:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[Any]					, *lowerCamelCase	:					Optional[int]					, **lowerCamelCase	:					List[str]						)->	Tuple:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					Optional[int]					, *lowerCamelCase	:					List[str]					, **lowerCamelCase	:					Tuple						)->	str:
          requires_backends(self					, ["""vision"""]						)







class 					_A						(						metaclass=UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= ['vision']




   def __init__(	self	:					List[str]					, *lowerCamelCase	:					Dict					, **lowerCamelCase	:					List[str]						)->	Dict:
          requires_backends(self					, ["""vision"""]						)




