'''simple docstring'''




import math



def     __snake_case			(							lowerCAmelCase							:  int      ):

 if not isinstance(a_   ,	a_      ):
  __UpperCAmelCase								=       F"""Input value of [number={number}] must be an integer"""
  raise TypeError(a_      )

 if number < 1:
  __UpperCAmelCase								=       F"""Input value of [number={number}] must be > 0"""
  raise ValueError(a_      )
 elif number == 1:
  return 3
 elif number == 2:
  return 5
 else:
  __UpperCAmelCase								=       int(math.log(number // 3   ,	2      )      ) + 2

  __UpperCAmelCase								=       [3, 5]
  __UpperCAmelCase								=       2
  __UpperCAmelCase								=       3
  for block in range(1   ,	a_      ):
   for _ in range(a_      ):
    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					:		int							      =		0
          try:
               _UpperCamelCase					:		Tuple							      =		proth(number)
          except ValueError:
               print(f"ValueError: there is no {number}th Proth number")
               continue

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











'''simple docstring'''

def 				snake_case       (  a_				:			str     , a_				:			Optional[int]						)							->					Any:





      """simple docstring"""

      UpperCamelCase_					: Tuple            =				(boundary[1] - boundary[0]) / steps
      UpperCamelCase_					: Dict            =				boundary[0]
      UpperCamelCase_					: Any            =				boundary[1]
      UpperCamelCase_					: Union[str, Any]            =				make_points(a_     , a_     , a_						)
      UpperCamelCase_					: Any            =				0.0
      y += (h / 2.0) * f(a_						)
      for i in x_i:
            # print(i)
            y += h * f(a_						)
      y += (h / 2.0) * f(a_						)
      return y



def 				snake_case       (  a_				:			Tuple     , a_				:			Any     , a_				:			Tuple						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Optional[int]            =				a + h
      while x < (b - h):
            yield x
            UpperCamelCase_					: List[str]            =				x + h



def 				snake_case       (  a_				:			List[str]						)							->					Tuple:  # enter your function here





      """simple docstring"""

      UpperCamelCase_					: int            =				(x - 0) * (x - 0)
      return y



def 				snake_case       (  )							->					Dict:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				0.0  # Lower bound of integration
      UpperCamelCase_					: Optional[int]            =				1.0  # Upper bound of integration
      UpperCamelCase_					: Optional[Any]            =				10.0  # define number of steps or resolution
      UpperCamelCase_					: Optional[Any]            =				[a, b]  # define boundary of integration
      UpperCamelCase_					: Any            =				method_a(a_     , a_						)
      print(f"y = {y}"						)


if __name__ == "__main__":
      main()






