





"""simple docstring"""






from math import factorial

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

def      __A   (      a_    :int)		->		int:
				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      __A   (      a_    :int = 60 ,							a_    :int = 1_00_00_00)		->		int:

				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
				__a			:    int      							=	0
				# the cached sizes of the previous chains
				__a			:    dict[int, int]      							=	{}

				for start_chain_element in range(1 ,							a_):
								# The temporary set will contain the elements of the chain
								__a			:    Tuple      							=	set()
								__a			:    Union[str, Any]      							=	0

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

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

								__a			:    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()}')






'''simple docstring'''

from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__		:     Tuple			=							{'configuration_mmbt': ['MMBTConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowercase__		:     int			=							['MMBTForClassification', 'MMBTModel', 'ModalEmbeddings']


if TYPE_CHECKING:
   from .configuration_mmbt import MMBTConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings

else:
   import sys

   lowercase__		:     List[Any]			=							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



