




from math import factorial

_lowerCamelCase	:		dict[str, int]							       =   {str(digit): factorial(digit) for digit in range(10)}







def SCREAMING_SNAKE_CASE				(       lowercase_						)   ->       int:



       """simple docstring"""

       if not isinstance(lowercase_ ,				lowercase_						):
              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(lowercase_						)						)







def SCREAMING_SNAKE_CASE				(       lowercase_ = 60 ,				lowercase_ = 1_000_000						)   ->       int:



       """simple docstring"""

       if not isinstance(lowercase_ ,				lowercase_						) or not isinstance(lowercase_ ,				lowercase_						):
              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
       A__       =    0
       # the cached sizes of the previous chains
       A__       =    {}

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

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

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

              A__       =    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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCamelCase	:		List[str]							       =   {"""configuration_vit_msn""": ["""VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTMSNConfig"""]}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase	:		List[Any]							       =   [
      """VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """ViTMSNModel""",
      """ViTMSNForImageClassification""",
      """ViTMSNPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vit_msn import (
        VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
        ViTMSNForImageClassification,
        ViTMSNModel,
        ViTMSNPreTrainedModel,
    )

else:
  import sys

  _lowerCamelCase	:		Tuple							       =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


