

from math import factorial

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

def       __snake_case						( __UpperCamelCase	: int    ):



      """simple docstring"""

      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       __snake_case						( __UpperCamelCase	: int = 60				,__UpperCamelCase	: int = 100_0000    ):



      """simple docstring"""

      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
      A_						  =				0
      # the cached sizes of the previous chains
      A_						  =				{}

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

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

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

            A_						  =				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 							lowerCamelCase	(					_snake_case	:    int = 50_000_000							):





    '''simple docstring'''


    lowercase__									=    set()
    lowercase__									=    int((limit - 24) ** (1 / 2)							)

    lowercase__									=    set(range(3  ,prime_square_limit + 1  ,2							)							)
    primes.add(2							)
    for p in range(3  ,prime_square_limit + 1  ,2							):
        if p not in primes:
            continue
        primes.difference_update(set(range(p * p  ,prime_square_limit + 1  ,_snake_case							)							)							)

    for primea in primes:
        lowercase__									=    primea * primea
        for primea in primes:
            lowercase__									=    primea * primea * primea
            if square + cube >= limit - 16:
                break
            for primea in primes:
                lowercase__									=    primea * primea * primea * primea
                lowercase__									=    square + cube + tetr
                if total >= limit:
                    break
                ret.add(_snake_case							)

    return len(_snake_case							)


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




