

from math import factorial

lowercase_									=   {str(digit): factorial(digit) for digit in range(1_0)}
def      a      (			A__	:   int     )    ->      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      a      (			A__	:   int = 60      ,   A__	:   int = 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
      _lowercase	       =0
      # the cached sizes of the previous chains
      _lowercase	       ={}

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

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

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

            _lowercase	       =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 						_a    (      a :float	,							a :float )							->			float:
 return price * (1 + tax_rate)


if __name__ == "__main__":
     print(f"""{price_plus_tax(100, 0.25) = }""")
     print(f"""{price_plus_tax(125.50, 0.05) = }""")


