






class 							A_    :






 '''simple docstring'''




 def __init__(	self							,  _A) ->		None:

     """simple docstring"""



     _UpperCAmelCase				:      List[str]			  =				set_counts
     _UpperCAmelCase				:      Optional[int]			  =				max(_A)
     _UpperCAmelCase				:      Union[str, Any]			  =				len(_A)
     _UpperCAmelCase				:      Optional[int]			  =				[1] * num_sets
     _UpperCAmelCase				:      Optional[int]			  =				list(range(_A))


 def  snake_case__				(	self							,  _A							,  _A) ->		bool:

     """simple docstring"""



     _UpperCAmelCase				:      Optional[Any]			  =				self.get_parent(_A)
     _UpperCAmelCase				:      Dict			  =				self.get_parent(_A)

     if src_parent == dst_parent:
         return False

     if self.ranks[dst_parent] >= self.ranks[src_parent]:
         self.set_counts[dst_parent] += self.set_counts[src_parent]
         _UpperCAmelCase				:      Any			  =				0
         _UpperCAmelCase				:      Union[str, Any]			  =				dst_parent
         if self.ranks[dst_parent] == self.ranks[src_parent]:
             self.ranks[dst_parent] += 1
         _UpperCAmelCase				:      Dict			  =				self.set_counts[dst_parent]
     else:
         self.set_counts[src_parent] += self.set_counts[dst_parent]
         _UpperCAmelCase				:      Dict			  =				0
         _UpperCAmelCase				:      Dict			  =				src_parent
         _UpperCAmelCase				:      List[Any]			  =				self.set_counts[src_parent]

     _UpperCAmelCase				:      Optional[Any]			  =				max(self.max_set							,  _A)
     return True


 def  snake_case__				(	self							,  _A) ->		int:

     """simple docstring"""



     if self.parents[disj_set] == disj_set:
         return disj_set
     _UpperCAmelCase				:      Dict			  =				self.get_parent(self.parents[disj_set])
     return self.parents[disj_set]












import math

def      _lowerCamelCase	(						__A    :							int )      ->					int:

    if not isinstance(__A		,		__A ):
        _UpperCAmelCase				:      List[Any]			  =				f'''Input value of [number={number}] must be an integer'''
        raise TypeError(__A )

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

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

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




