


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







def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	if not isinstance(__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							):
		raise TypeError('Input value must be an \'int\' type'							)

	lowercase       =    0
	while number:
		position += 1
		number >>= 1

	return position


if __name__ == "__main__":
	import doctest

	doctest.testmod()

