





from math import factorial

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


def 			SCREAMING_SNAKE_CASE (			_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 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase = 60		,      _UpperCAmelCase = 100_0000					)     ->	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__       : Any   					=						0
    # the cached sizes of the previous chains
    lowerCamelCase__       : dict[int, int]   					=						{}

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

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

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

        lowerCamelCase__       : 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 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase = 200					)     ->	int:
    lowerCamelCase__       : Dict   					=						[1, 2, 5, 10, 20, 50, 100, 200]
    lowerCamelCase__       : Union[str, Any]   					=						[0] * (pence + 1)
    lowerCamelCase__       : List[str]   					=						1  # base case: 1 way to make 0 pence

    for coin in coins:
        for i in range(_UpperCAmelCase		,      pence + 1		,      1					):
            number_of_ways[i] += number_of_ways[i - coin]
    return number_of_ways[pence]


if __name__ == "__main__":
    assert solution(2_00) == 7_36_82





