





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__    :      Optional[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__    :      Tuple					 =		set()
        lowerCamelCase__    :      Optional[int]					 =		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__    :      Union[str, 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()}""")












from __future__ import annotations

import math


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     bool:

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5						,	int(math.sqrt(_UpperCAmelCase ) + 1 )						,	6 ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True


_UpperCAmelCase				:       Any	   =				[num for num in range(3, 10_00_01, 2) if not is_prime(num)]


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     list[int]:
    if not isinstance(_UpperCAmelCase						,	_UpperCAmelCase ):
        raise ValueError('n must be an integer' )
    if n <= 0:
        raise ValueError('n must be >= 0' )

    lowerCamelCase__    :      int					 =		[]
    for num in range(len(_UpperCAmelCase ) ):
        lowerCamelCase__    :      Union[str, Any]					 =		0
        while 2 * i * i <= odd_composites[num]:
            lowerCamelCase__    :      Dict					 =		odd_composites[num] - 2 * i * i
            if is_prime(_UpperCAmelCase ):
                break
            i += 1
        else:
            list_nums.append(odd_composites[num] )
            if len(_UpperCAmelCase ) == n:
                return list_nums

    return []


def        SCREAMING_SNAKE_CASE      (       )			->     int:
    return compute_nums(1 )[0]


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





