





from math import factorial

UpperCAmelCase__						:			dict[str, int]									={str(digit): factorial(digit) for digit in range(10)}





def      _lowercase					(						_UpperCAmelCase				)						->  int:
				if not isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								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(_UpperCAmelCase				)				)





def      _lowercase					(						_UpperCAmelCase = 60			,      _UpperCAmelCase = 1_00_00_00				)						->  int:

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

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

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

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

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












from abc import ABC, abstractmethod
from argparse import ArgumentParser

class       __A     (						a    ):


				@staticmethod
				@abstractmethod
				def _snake_case       (		UpperCAmelCase_							):
								raise NotImplementedError()


				@abstractmethod
				def _snake_case       (		self							):
								raise NotImplementedError()





