





'''simple docstring'''




__SCREAMING_SNAKE_CASE     :int       =				{0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

__SCREAMING_SNAKE_CASE     :Any       =				{0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}
def 	UpperCAmelCase_							(					__lowercase							:      dict[int, list[int]]			,     __lowercase							:      int			,     __lowercase							:      list[bool]       )		->       list[int]:


     '''simple docstring'''



     _UpperCAmelCase     							=   True
     _UpperCAmelCase     							=   []

     for neighbour in graph[vert]:
          if not visited[neighbour]:
               order += topology_sort(__lowercase			,     __lowercase			,     __lowercase       )

     order.append(__lowercase       )

     return order
def 	UpperCAmelCase_							(					__lowercase							:      dict[int, list[int]]			,     __lowercase							:      int			,     __lowercase							:      list[bool]       )		->       list[int]:


     '''simple docstring'''



     _UpperCAmelCase     							=   True
     _UpperCAmelCase     							=   [vert]

     for neighbour in reversed_graph[vert]:
          if not visited[neighbour]:
               component += find_components(__lowercase			,     __lowercase			,     __lowercase       )

     return component






def 	UpperCAmelCase_							(					__lowercase							:      dict[int, list[int]]       )		->       list[list[int]]:


     '''simple docstring'''



     _UpperCAmelCase     							=   len(__lowercase       ) * [False]
     _UpperCAmelCase     							=   {vert: [] for vert in range(len(__lowercase       )       )}

     for vert, neighbours in graph.items():
          for neighbour in neighbours:
               reversed_graph[neighbour].append(__lowercase       )

     _UpperCAmelCase     							=   []
     for i, was_visited in enumerate(__lowercase       ):
          if not was_visited:
               order += topology_sort(__lowercase			,     __lowercase			,     __lowercase       )

     _UpperCAmelCase     							=   []
     _UpperCAmelCase     							=   len(__lowercase       ) * [False]

     for i in range(len(__lowercase       )       ):
          _UpperCAmelCase     							=   order[len(__lowercase       ) - i - 1]
          if not visited[vert]:
               _UpperCAmelCase     							=   find_components(__lowercase			,     __lowercase			,     __lowercase       )
               components_list.append(__lowercase       )

     return components_list











"""simple docstring"""





import math
def  __A   (_SCREAMING_SNAKE_CASE			)					->int:





  """simple docstring"""


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

  if number < 1:
    lowerCAmelCase__			:Dict											=							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:
    lowerCAmelCase__			:Union[str, Any]											=							int(math.log(number // 3     ,   2			)			) + 2

    lowerCAmelCase__			:Optional[Any]											=							[3, 5]
    lowerCAmelCase__			:Optional[Any]											=							2
    lowerCAmelCase__			: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):
    __A											=		0
    try:
      __A											=		proth(number)
    except ValueError:
      print(F'''ValueError: there is no {number}th Proth number''')
      continue

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