"""simple docstring"""





from math import factorial

__A  =				{str(digit): factorial(digit) for digit in range(10)}


def    lowercase_   (   _lowerCamelCase:	int      ) ->      int:



							'''simple docstring'''

							if not isinstance(_lowerCamelCase						,   _lowerCamelCase      ):
														raise TypeError("Parameter number must be int"      )

							if number < 0:
														raise ValueError("Parameter number must be greater than or equal to 0"      )

							# Converts number in string to iterate on its digits and adds its factorial.
							return sum(DIGIT_FACTORIAL[digit] for digit in str(_lowerCamelCase      )      )


def    lowercase_   (   _lowerCamelCase:	int = 60						,   _lowerCamelCase:	int = 1000000      ) ->      int:



							'''simple docstring'''

							if not isinstance(_lowerCamelCase						,   _lowerCamelCase      ) or not isinstance(_lowerCamelCase						,   _lowerCamelCase      ):
														raise TypeError("Parameters chain_length and number_limit must be int"      )

							if chain_length <= 0 or number_limit <= 0:
														raise ValueError(
														    "Parameters chain_length and number_limit must be greater than 0"      )

							# the counter for the chains with the exact desired length
							__lowerCamelCase					:		Optional[int]		   =     0
							# the cached sizes of the previous chains
							__lowerCamelCase					:		dict[int, int]		   =     {}

							for start_chain_element in range(1						,   _lowerCamelCase      ):
														# The temporary set will contain the elements of the chain
														__lowerCamelCase					:		Dict		   =     set()
														__lowerCamelCase					:		Tuple		   =     0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														__lowerCamelCase					:		Tuple		   =     start_chain_element
														while (
														    chain_element not in chain_sets_lengths
														    and chain_element not in chain_set
														    and chain_set_length <= chain_length
														):
																					chain_set.add(_lowerCamelCase      )
																					chain_set_length += 1
																					__lowerCamelCase					:		Any		   =     digit_factorial_sum(_lowerCamelCase      )

														if chain_element in chain_sets_lengths:
																					chain_set_length += chain_sets_lengths[chain_element]

														__lowerCamelCase					:		Optional[Any]		   =     chain_set_length

														# If chain contains the exact amount of elements increase the counter
														if chain_set_length == chain_length:
																					chains_counter += 1

							return chains_counter


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				print(F"""{solution()}""")
"""simple docstring"""





import math


def    lowercase_   (   _lowerCamelCase:	int      ) ->      bool:



							'''simple docstring'''

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5						,   int(math.sqrt(_lowerCamelCase      ) + 1      )						,   6      ):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True


def    lowercase_   (   _lowerCamelCase:	int = 10001      ) ->      int:



							'''simple docstring'''

							try:
														__lowerCamelCase					:		Optional[int]		   =     int(_lowerCamelCase      )
							except (TypeError, ValueError):
														raise TypeError("Parameter nth must be int or castable to int."      ) from None
							if nth <= 0:
														raise ValueError("Parameter nth must be greater than or equal to one."      )
							__lowerCamelCase					:		list[int]		   =     []
							__lowerCamelCase					:		Tuple		   =     2
							while len(_lowerCamelCase      ) < nth:
														if is_prime(_lowerCamelCase      ):
																					primes.append(_lowerCamelCase      )
																					num += 1
														else:
																					num += 1
							return primes[len(_lowerCamelCase      ) - 1]


if __name__ == "__main__":
				print(F"""{solution() = }""")