





"""simple docstring"""





from math import factorial

__A											=						{str(digit): factorial(digit) for digit in range(10)}
def 					__A  (_SCREAMING_SNAKE_CASE     )   ->int:





  """simple docstring"""


  if not isinstance(_SCREAMING_SNAKE_CASE	,  _SCREAMING_SNAKE_CASE     ):
    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(_SCREAMING_SNAKE_CASE     )     )
def 					__A  (_SCREAMING_SNAKE_CASE = 60	,  _SCREAMING_SNAKE_CASE = 100_0000     )   ->int:





  """simple docstring"""


  if not isinstance(_SCREAMING_SNAKE_CASE	,  _SCREAMING_SNAKE_CASE     ) or not isinstance(_SCREAMING_SNAKE_CASE	,  _SCREAMING_SNAKE_CASE     ):
    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__     :Union[str, Any]											=				0
  # the cached sizes of the previous chains
  lowerCAmelCase__     :dict[int, int]											=				{}

  for start_chain_element in range(1	,  _SCREAMING_SNAKE_CASE     ):
    # The temporary set will contain the elements of the chain
    lowerCAmelCase__     :Optional[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__     :Dict											=				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(_SCREAMING_SNAKE_CASE     )
      chain_set_length += 1
      lowerCAmelCase__     :int											=				digit_factorial_sum(_SCREAMING_SNAKE_CASE     )

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

    lowerCAmelCase__     :Union[str, Any]											=				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()}''')





'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__a  			=						{
    "configuration_bigbird_pegasus": [
        "BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "BigBirdPegasusConfig",
        "BigBirdPegasusOnnxConfig",
    ],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __a  			=						[
           "BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST",
           "BigBirdPegasusForCausalLM",
           "BigBirdPegasusForConditionalGeneration",
           "BigBirdPegasusForQuestionAnswering",
           "BigBirdPegasusForSequenceClassification",
           "BigBirdPegasusModel",
           "BigBirdPegasusPreTrainedModel",
       ]


if TYPE_CHECKING:
       from .configuration_bigbird_pegasus import (
           BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
           BigBirdPegasusConfig,
           BigBirdPegasusOnnxConfig,
       )

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_bigbird_pegasus import (
                  BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
                  BigBirdPegasusForCausalLM,
                  BigBirdPegasusForConditionalGeneration,
                  BigBirdPegasusForQuestionAnswering,
                  BigBirdPegasusForSequenceClassification,
                  BigBirdPegasusModel,
                  BigBirdPegasusPreTrainedModel,
              )


else:
       import sys

       __a  			=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
