


'''simple docstring'''
def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase = 1000     ):






       """simple docstring"""





       if (not isinstance(UpperCAmelCase    ,       UpperCAmelCase     )) or (digit_position <= 0):
              raise ValueError("""Digit position must be a positive integer"""     )
       elif (not isinstance(UpperCAmelCase    ,       UpperCAmelCase     )) or (precision < 0):
              raise ValueError("""Precision must be a nonnegative integer"""     )

       # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
       # accurate
       snake_case__					:	Dict          =					(
           4 * _subsum(UpperCAmelCase    ,       1    ,       UpperCAmelCase     )
           - 2 * _subsum(UpperCAmelCase    ,       4    ,       UpperCAmelCase     )
           - _subsum(UpperCAmelCase    ,       5    ,       UpperCAmelCase     )
           - _subsum(UpperCAmelCase    ,       6    ,       UpperCAmelCase     )
       )

       # return the first hex digit of the fractional part of the result
       return hex(int((sum_result % 1) * 16     )     )[2:]



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Optional[Any]          =					0.0
       for sum_index in range(digit_pos_to_extract + precision     ):
              snake_case__					:	Optional[Any]          =					8 * sum_index + denominator_addend
              if sum_index < digit_pos_to_extract:
                     # if the exponential term is an integer and we mod it by the denominator
                     # before dividing, only the integer part of the sum will change;
                     # the fractional part will not
                     snake_case__					:	str          =					pow(
                         16    ,       digit_pos_to_extract - 1 - sum_index    ,       UpperCAmelCase     )
              else:
                     snake_case__					:	Optional[int]          =					pow(16    ,       digit_pos_to_extract - 1 - sum_index     )
              total += exponential_term / denominator
       return total


if __name__ == "__main__":
     import doctest

     doctest.testmod()








'''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"""]						)




