





from math import factorial

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





def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							if not isinstance(a__   ,			a__       ):
														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(a__       )       )





def     _UpperCamelCase     (a__   :int = 60   ,			a__   :int = 100_0000       ):






							"""simple docstring"""





							if not isinstance(a__   ,			a__       ) or not isinstance(a__   ,			a__       ):
														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
							UpperCamelCase__				     =			0
							# the cached sizes of the previous chains
							UpperCamelCase__				     =			{}

							for start_chain_element in range(1   ,			a__       ):
														# The temporary set will contain the elements of the chain
														UpperCamelCase__				     =			set()
														UpperCamelCase__				     =			0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														UpperCamelCase__				     =			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(a__       )
																					chain_set_length += 1
																					UpperCamelCase__				     =			digit_factorial_sum(a__       )

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

														UpperCamelCase__				     =			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()}""")











def     _UpperCamelCase     (a__   :int       ):






							"""simple docstring"""





							if divisor % 5 == 0 or divisor % 2 == 0:
														return 0
							UpperCamelCase__				     =			1
							UpperCamelCase__				     =			1
							while repunit:
														UpperCamelCase__				     =			(10 * repunit + 1) % divisor
														repunit_index += 1
							return repunit_index





def     _UpperCamelCase     (a__   :int = 100_0000       ):






							"""simple docstring"""





							UpperCamelCase__				     =			limit - 1
							if divisor % 2 == 0:
														divisor += 1
							while least_divisible_repunit(a__       ) <= limit:
														divisor += 2
							return divisor


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




