





from ..utils import DummyObject, requires_backends







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   str							,    *A			:   int							,    **A			:   Optional[Any]		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Tuple							,    *A			:   str							,    **A			:   Dict		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   List[str]							,    *A			:   Tuple							,    **A			:   Optional[Any]		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   str							,    *A			:   int							,    **A			:   Any		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Union[str, Any]							,    *A			:   List[str]							,    **A			:   List[Any]		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Optional[Any]							,    *A			:   int							,    **A			:   int		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   List[Any]							,    *A			:   int							,    **A			:   Optional[int]		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   int							,    *A			:   List[str]							,    **A			:   Dict		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   List[str]							,    *A			:   str							,    **A			:   Optional[int]		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   int							,    *A			:   List[Any]							,    **A			:   Union[str, Any]		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Optional[int]							,    *A			:   Any							,    **A			:   Any		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   List[Any]							,    *A			:   List[str]							,    **A			:   Dict		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   Any							,    *A			:   Union[str, Any]							,    **A			:   List[str]		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Optional[Any]							,    *A			:   List[str]							,    **A			:   int		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   Optional[int]							,    *A			:   str							,    **A			:   List[Any]		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)







class    __snake_case	(							metaclass=__lowerCamelCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					['torch', 'transformers', 'onnx']




       def __init__(  self			:   Tuple							,    *A			:   Optional[Any]							,    **A			:   List[str]		):
         requires_backends(self							,    ["""torch""", """transformers""", """onnx"""]		)




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   int							,    *A			:   int							,    **A			:   str		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)






       @classmethod
       def 							UpperCAmelCase__			(  cls			:   str							,    *A			:   Optional[int]							,    **A			:   Tuple		):
         requires_backends(cls							,    ["""torch""", """transformers""", """onnx"""]		)













import math







def       A__							(   SCREAMING_SNAKE_CASE__)       ->   int:

  if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__):
    __snake_case:						Optional[int]			  =						F'''Input value of [number={number}] must be an integer'''
    raise TypeError(SCREAMING_SNAKE_CASE__)

  if number < 1:
    __snake_case:						Optional[int]			  =						F'''Input value of [number={number}] must be > 0'''
    raise ValueError(SCREAMING_SNAKE_CASE__)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    __snake_case:						List[Any]			  =						int(math.log(number // 3 , 2)) + 2

    __snake_case:						str			  =						[3, 5]
    __snake_case:						int			  =						2
    __snake_case:						List[str]			  =						3
    for block in range(1 , SCREAMING_SNAKE_CASE__):
      for _ in range(SCREAMING_SNAKE_CASE__):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1])
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      for number in range(11):
            __UpperCAmelCase	:       Optional[int]    	=							0
            try:
                  __UpperCAmelCase	:       int    	=							proth(number)
            except ValueError:
                  print(f'ValueError: there is no {number}th Proth number')
                  continue

            print(f'The {number}th Proth number: {value}')






