



from math import factorial

__snake_case    :		dict[str, int]  ={str(digit): factorial(digit) for digit in range(1_0)}






def      lowerCAmelCase__		(   lowerCamelCase_		:		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      lowerCAmelCase__		(   lowerCamelCase_		:		int = 60	,lowerCamelCase_		:		int = 1000000):





				'''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__					:    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__					:    Union[str, Any]												=					set()
								lowerCAmelCase__					:    str												=					0

								# Stop computing the chain when you find a cached size, a repeating item or the
								# length is greater then the desired one.
								lowerCAmelCase__					:    Union[str, Any]												=					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__					:    Optional[int]												=					digit_factorial_sum(lowerCamelCase_)

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

								lowerCAmelCase__					:    Optional[int]												=					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      lowerCAmelCase__		(   lowerCamelCase_		:		str	,lowerCamelCase_		:		str):





				'''simple docstring'''

				lowerCAmelCase__					:    Optional[Any]												=					len(lowerCamelCase_)
				lowerCAmelCase__					:    str												=					len(lowerCamelCase_)
				lowerCAmelCase__					:    Union[str, Any]												=					[[False for _ in range(m + 1)] for _ in range(n + 1)]
				lowerCAmelCase__					:    List[Any]												=					True
				for i in range(lowerCamelCase_):
								for j in range(m + 1):
												if dp[i][j]:
																if j < m and a[i].upper() == b[j]:
																				lowerCAmelCase__					:    int												=					True
																if a[i].islower():
																				lowerCAmelCase__					:    int												=					True
				return dp[n][m]


if __name__ == "__main__":
							import doctest

							doctest.testmod()

