


'''simple docstring'''







from math import factorial

a__  :					dict[str, int]        =       {str(digit): factorial(digit) for digit in range(1_0)}







def _UpperCamelCase       (     __A    )							->		int:


      '''simple docstring'''



      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 _UpperCamelCase       (     __A = 60      ,			__A = 1000000    )							->		int:


      '''simple docstring'''



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

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

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

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

            UpperCamelCase__										=				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()}""")












import math
import unittest



def    __lowercase   (      _SCREAMING_SNAKE_CASE	) ->   bool:


      '''simple docstring'''


      assert isinstance(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE	) and (
          number >= 0
      ), "'number' must been an int and positive"

      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(_SCREAMING_SNAKE_CASE	) + 1	) ,						6	):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True

class 		UpperCamelCase__ (      unittest.TestCase   ):



     '''simple docstring'''

     def 				SCREAMING_SNAKE_CASE__  (							self						:    Dict       )     ->		Tuple:




           '''simple docstring'''


           self.assertTrue(is_prime(2       )       )
           self.assertTrue(is_prime(3       )       )
           self.assertTrue(is_prime(5       )       )
           self.assertTrue(is_prime(7       )       )
           self.assertTrue(is_prime(11       )       )
           self.assertTrue(is_prime(13       )       )
           self.assertTrue(is_prime(17       )       )
           self.assertTrue(is_prime(19       )       )
           self.assertTrue(is_prime(23       )       )
           self.assertTrue(is_prime(29       )       )






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]       )     ->		Tuple:




           '''simple docstring'''


           with self.assertRaises(lowerCamelCase__       ):
                 is_prime(-19       )
           self.assertFalse(
               is_prime(0       )						,"""Zero doesn't have any positive factors, primes must have exactly two."""						,)
           self.assertFalse(
               is_prime(1       )						,"""One only has 1 positive factor, primes must have exactly two."""						,)
           self.assertFalse(is_prime(2 * 2       )       )
           self.assertFalse(is_prime(2 * 3       )       )
           self.assertFalse(is_prime(3 * 3       )       )
           self.assertFalse(is_prime(3 * 5       )       )
           self.assertFalse(is_prime(3 * 5 * 7       )       )


if __name__ == "__main__":
      unittest.main()


