
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


lowerCamelCase__    :		Tuple          =   {
    """configuration_canine""": ["""CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CanineConfig"""],
    """tokenization_canine""": ["""CanineTokenizer"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase__    :		Tuple          =   [
         """CANINE_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """CanineForMultipleChoice""",
         """CanineForQuestionAnswering""",
         """CanineForSequenceClassification""",
         """CanineForTokenClassification""",
         """CanineLayer""",
         """CanineModel""",
         """CaninePreTrainedModel""",
         """load_tf_weights_in_canine""",
     ]


if TYPE_CHECKING:
     from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
     from .tokenization_canine import CanineTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_canine import (
              CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
              CanineForMultipleChoice,
              CanineForQuestionAnswering,
              CanineForSequenceClassification,
              CanineForTokenClassification,
              CanineLayer,
              CanineModel,
              CaninePreTrainedModel,
              load_tf_weights_in_canine,
          )


else:
     import sys

     lowerCamelCase__    :		Optional[int]          =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)








from math import factorial

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

def 		UpperCamelCase	(      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 		UpperCamelCase	(      lowercase_ = 60 , lowercase_ = 1_00_00_00   )		->	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
  lowercase__  :   List[Any]    		=      0
  # the cached sizes of the previous chains
  lowercase__  :   dict[int, int]    		=      {}

  for start_chain_element in range(1 , lowercase_   ):
    # The temporary set will contain the elements of the chain
    lowercase__  :   Optional[Any]    		=      set()
    lowercase__  :   Union[str, Any]    		=      0

    # Stop computing the chain when you find a cached size, a repeating item or the
    # length is greater then the desired one.
    lowercase__  :   Union[str, Any]    		=      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
      lowercase__  :   str    		=      digit_factorial_sum(lowercase_   )

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

    lowercase__  :   str    		=      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()}''')






