'''simple docstring'''




_lowercase						: Optional[int]						=						{
    "meter": "m",
    "kilometer": "km",
    "megametre": "Mm",
    "gigametre": "Gm",
    "terametre": "Tm",
    "petametre": "Pm",
    "exametre": "Em",
    "zettametre": "Zm",
    "yottametre": "Ym",
}
# Exponent of the factor(meter)
_lowercase						: Optional[Any]						=						{
    "m": 0,
    "km": 3,
    "Mm": 6,
    "Gm": 9,
    "Tm": 12,
    "Pm": 15,
    "Em": 18,
    "Zm": 21,
    "Ym": 24,
}




def 							lowerCamelCase	(      UpperCAmelCase__       :					float      ,      UpperCAmelCase__       :					str      ,      UpperCAmelCase__       :					str )			->      float:
							lowercase_					:			Tuple										=       from_type.lower().strip("""s""" )
							lowercase_					:			Union[str, Any]										=       to_type.lower().strip("""s""" )

							lowercase_					:			Union[str, Any]										=       UNIT_SYMBOL.get(UpperCAmelCase__      ,      UpperCAmelCase__ )
							lowercase_					:			Any										=       UNIT_SYMBOL.get(UpperCAmelCase__      ,      UpperCAmelCase__ )

							if from_sanitized not in METRIC_CONVERSION:
														lowercase_					:			Dict										=       (
														    F'''Invalid \'from_type\' value: {from_type!r}.\n'''
														    F'''Conversion abbreviations are: {', '.join(UpperCAmelCase__ )}'''
														)
														raise ValueError(UpperCAmelCase__ )
							if to_sanitized not in METRIC_CONVERSION:
														lowercase_					:			Dict										=       (
														    F'''Invalid \'to_type\' value: {to_type!r}.\n'''
														    F'''Conversion abbreviations are: {', '.join(UpperCAmelCase__ )}'''
														)
														raise ValueError(UpperCAmelCase__ )
							lowercase_					:			List[Any]										=       METRIC_CONVERSION[from_sanitized]
							lowercase_					:			Optional[Any]										=       METRIC_CONVERSION[to_sanitized]
							lowercase_					:			List[Any]										=       1

							if from_exponent > to_exponent:
														lowercase_					:			Dict										=       from_exponent - to_exponent
							else:
														lowercase_					:			Any										=       -(to_exponent - from_exponent)

							return value * pow(10      ,      UpperCAmelCase__ )


if __name__ == "__main__":
						from doctest import testmod

						testmod()






'''simple docstring'''




import math




def 							lowerCamelCase	(      UpperCAmelCase__       :					int )			->      int:

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

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

														lowercase_					:			Any										=       [3, 5]
														lowercase_					:			List[Any]										=       2
														lowercase_					:			Optional[Any]										=       3
														for block in range(1      ,      UpperCAmelCase__ ):
																					for _ in range(UpperCAmelCase__ ):
																												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):
												_lowercase						: Optional[Any]						=						0
												try:
																		_lowercase						: str						=						proth(number)
												except ValueError:
																		print(f"""ValueError: there is no {number}th Proth number""")
																		continue

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





