



'''simple docstring'''





from math import factorial

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





def 		__snake_case(							_lowerCAmelCase						)						->					int:
      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 		__snake_case(							_lowerCAmelCase = 60	,  _lowerCAmelCase = 1_000_000						)						->					int:

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

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

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

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

            snake_case__    :       str       		= 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'''





def 		__snake_case(							)						->					Optional[Any]:
      for n in range(1	,  1_000_000						):
            yield n * (n + 1) // 2





def 		__snake_case(							_lowerCAmelCase						)						->					str:
      snake_case__    :       Optional[int]       		= 1
      snake_case__    :       List[Any]       		= 2
      while i * i <= n:
            snake_case__    :       Dict       		= 0
            while n % i == 0:
                  n //= i
                  multiplicity += 1
            divisors_count *= multiplicity + 1
            i += 1
      if n > 1:
            divisors_count *= 2
      return divisors_count





def 		__snake_case(							)						->					List[str]:
      return next(i for i in triangle_number_generator() if count_divisors(_lowerCAmelCase						) > 500						)


if __name__ == "__main__":
       print(solution())
