

'''simple docstring'''
import os
import re
import warnings
from shutil import copyfile
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer


if TYPE_CHECKING:
    from ...tokenization_utils_base import TextInput
from ...utils import logging


_snake_case      =    logging.get_logger(__name__)

_snake_case      =    {'''vocab_file''': '''spiece.model'''}

_snake_case      =    {
    '''vocab_file''': {
        '''t5-small''': '''https://huggingface.co/t5-small/resolve/main/spiece.model''',
        '''t5-base''': '''https://huggingface.co/t5-base/resolve/main/spiece.model''',
        '''t5-large''': '''https://huggingface.co/t5-large/resolve/main/spiece.model''',
        '''t5-3b''': '''https://huggingface.co/t5-3b/resolve/main/spiece.model''',
        '''t5-11b''': '''https://huggingface.co/t5-11b/resolve/main/spiece.model''',
    }
}


# TODO(PVP) - this should be removed in Transformers v5
_snake_case      =    {
    '''t5-small''': 512,
    '''t5-base''': 512,
    '''t5-large''': 512,
    '''t5-3b''': 512,
    '''t5-11b''': 512,
}

_snake_case      =    '''▁'''


class   a__    (				__lowerCAmelCase    ):
   _SCREAMING_SNAKE_CASE       :	Any      			=				VOCAB_FILES_NAMES
   _SCREAMING_SNAKE_CASE       :	List[Any]      			=				PRETRAINED_VOCAB_FILES_MAP
   _SCREAMING_SNAKE_CASE       :	int      			=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _SCREAMING_SNAKE_CASE       :	List[str]      			=				["""input_ids""", """attention_mask"""]


   def __init__(					self     ,							_UpperCamelCase     ,							_UpperCamelCase="</s>"     ,							_UpperCamelCase="<unk>"     ,							_UpperCamelCase="<pad>"     ,							_UpperCamelCase=100     ,							_UpperCamelCase=None     ,							_UpperCamelCase = None     ,							_UpperCamelCase=True     ,							**_UpperCamelCase     ,							):





      """simple docstring"""





      if extra_ids > 0 and additional_special_tokens is None:
         _lowercase     : Optional[int]     	=  [f'''<extra_id_{i}>''' for i in range(_SCREAMING_SNAKE_CASE    )]
      elif extra_ids > 0 and additional_special_tokens is not None:
         # Check that we have the right number of extra_id special tokens
         _lowercase     : int     	=  len(set(filter(lambda _UpperCamelCase    : bool("extra_id" in str(_SCREAMING_SNAKE_CASE    )    )     ,							_SCREAMING_SNAKE_CASE    )    )    )
         if extra_tokens != extra_ids:
            raise ValueError(
                f'''Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are'''
                " provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids"
                " tokens"    )
      if legacy:
         logger.warning_once(
             f'''You are using the legacy behaviour of the {self.__class__}. This means that tokens that come after special tokens will not be properly handled. We recommend you to'''
             " read the related pull request available at https://github.com/huggingface/transformers/pull/24565"    )

      _lowercase     : Dict     	=  legacy
      _lowercase     : str     	=  {} if sp_model_kwargs is None else sp_model_kwargs

      super().__init__(
          eos_token=_SCREAMING_SNAKE_CASE     ,							unk_token=_SCREAMING_SNAKE_CASE     ,							pad_token=_SCREAMING_SNAKE_CASE     ,							extra_ids=_SCREAMING_SNAKE_CASE     ,							additional_special_tokens=_SCREAMING_SNAKE_CASE     ,							sp_model_kwargs=self.sp_model_kwargs     ,							legacy=_SCREAMING_SNAKE_CASE     ,							**_SCREAMING_SNAKE_CASE     ,							)

      _lowercase     : List[Any]     	=  vocab_file
      _lowercase     : Optional[Any]     	=  extra_ids

      _lowercase     : int     	=  spm.SentencePieceProcessor(**self.sp_model_kwargs    )
      self.sp_model.Load(_SCREAMING_SNAKE_CASE    )


   @staticmethod
   def 		_lowerCamelCase  (					_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase    ):





      """simple docstring"""





      if pretrained_model_name_or_path in TaTokenizer.max_model_input_sizes:
         _lowercase     : str     	=  TaTokenizer.max_model_input_sizes[pretrained_model_name_or_path]
         if init_max_model_length is not None and init_max_model_length != max_model_length:
            return init_max_model_length
         elif init_max_model_length is None:
            warnings.warn(
                "This tokenizer was incorrectly instantiated with a model max length of"
                f''' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this'''
                " behavior is kept to avoid breaking backwards compatibility when padding/encoding with"
                " `truncation is True`.\n- Be aware that you SHOULD NOT rely on"
                f''' {pretrained_model_name_or_path} automatically truncating your input to'''
                f''' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences'''
                f''' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with'''
                " `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please"
                " instantiate this tokenizer with `model_max_length` set to your preferred value."     ,							_SCREAMING_SNAKE_CASE     ,							)

      return max_model_length


   @property
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      return self.sp_model.get_piece_size() + self._extra_ids


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : str     	=  {self.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE    ): i for i in range(self.vocab_size    )}
      vocab.update(self.added_tokens_encoder    )
      return vocab


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							_UpperCamelCase = None     ,							_UpperCamelCase = False    ):





      """simple docstring"""





      if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=_SCREAMING_SNAKE_CASE     ,							token_ids_a=_SCREAMING_SNAKE_CASE     ,							already_has_special_tokens=_SCREAMING_SNAKE_CASE    )

      # normal case: some special tokens
      if token_ids_a is None:
         return ([0] * len(_SCREAMING_SNAKE_CASE    )) + [1]
      return ([0] * len(_SCREAMING_SNAKE_CASE    )) + [1] + ([0] * len(_SCREAMING_SNAKE_CASE    )) + [1]


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      return list(
          set(filter(lambda _UpperCamelCase    : bool(re.search(R"<extra_id_\d+>"     ,							_SCREAMING_SNAKE_CASE    )    ) is not None     ,							self.additional_special_tokens    )    )    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      return [self._convert_token_to_id(_SCREAMING_SNAKE_CASE    ) for token in self.get_sentinel_tokens()]


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase    ):





      """simple docstring"""





      if len(_SCREAMING_SNAKE_CASE    ) > 0 and token_ids[-1] == self.eos_token_id:
         warnings.warn(
             f'''This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated'''
             " eos tokens being added."    )
         return token_ids
      else:
         return token_ids + [self.eos_token_id]


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							_UpperCamelCase = None    ):





      """simple docstring"""





      _lowercase     : List[Any]     	=  [self.eos_token_id]

      if token_ids_a is None:
         return len(token_ids_a + eos    ) * [0]
      return len(token_ids_a + eos + token_ids_a + eos    ) * [0]


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							_UpperCamelCase = None    ):





      """simple docstring"""





      _lowercase     : List[str]     	=  self._add_eos_if_not_present(_SCREAMING_SNAKE_CASE    )
      if token_ids_a is None:
         return token_ids_a
      else:
         _lowercase     : int     	=  self._add_eos_if_not_present(_SCREAMING_SNAKE_CASE    )
         return token_ids_a + token_ids_a


   def __getstate__(					self    ):





      """simple docstring"""





      _lowercase     : List[str]     	=  self.__dict__.copy()
      _lowercase     : List[Any]     	=  None
      return state


   def __setstate__(					self     ,							_UpperCamelCase    ):





      """simple docstring"""





      _lowercase     : Dict     	=  d

      # for backward compatibility
      if not hasattr(self     ,							"sp_model_kwargs"    ):
         _lowercase     : Tuple     	=  {}

      _lowercase     : Tuple     	=  spm.SentencePieceProcessor(**self.sp_model_kwargs    )
      self.sp_model.Load(self.vocab_file    )


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							**_UpperCamelCase    ):





      """simple docstring"""





      if not self.legacy:
         _lowercase     : int     	=  SPIECE_UNDERLINE + text.replace(_SCREAMING_SNAKE_CASE     ,							" "    )
      return super().tokenize(_SCREAMING_SNAKE_CASE     ,							**_SCREAMING_SNAKE_CASE    )


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							**_UpperCamelCase    ):





      """simple docstring"""





      if not self.legacy:
         _lowercase     : int     	=  text.startswith(_SCREAMING_SNAKE_CASE    )
         if is_first:
            _lowercase     : int     	=  text[1:]

      _lowercase     : List[str]     	=  self.sp_model.encode(_SCREAMING_SNAKE_CASE     ,							out_type=_SCREAMING_SNAKE_CASE    )

      if not self.legacy and not is_first and not text.startswith(" "    ) and tokens[0].startswith(_SCREAMING_SNAKE_CASE    ):
         _lowercase     : int     	=  ([tokens[0][1:]] if len(tokens[0]    ) > 1 else []) + tokens[1:]
      return tokens


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase    ):





      """simple docstring"""





      if token.startswith("<extra_id_"    ):
         _lowercase     : List[Any]     	=  re.match(R"<extra_id_(\d+)>"     ,							_SCREAMING_SNAKE_CASE    )
         _lowercase     : List[str]     	=  int(match.group(1    )    )
         return self.vocab_size - num - 1
      return self.sp_model.piece_to_id(_SCREAMING_SNAKE_CASE    )


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase    ):





      """simple docstring"""





      if index < self.sp_model.get_piece_size():
         _lowercase     : List[str]     	=  self.sp_model.IdToPiece(_SCREAMING_SNAKE_CASE    )
      else:
         _lowercase     : List[str]     	=  f'''<extra_id_{self.vocab_size - 1 - index}>'''
      return token


   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase    ):





      """simple docstring"""





      _lowercase     : Any     	=  []
      _lowercase     : Union[str, Any]     	=  ""
      _lowercase     : Tuple     	=  False
      for token in tokens:
         # make sure that special tokens are not decoded using sentencepiece model
         if token in self.all_special_tokens:
            if not prev_is_special:
               out_string += " "
            out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE    ) + token
            _lowercase     : Dict     	=  True
            _lowercase     : int     	=  []
         else:
            current_sub_tokens.append(_SCREAMING_SNAKE_CASE    )
            _lowercase     : List[Any]     	=  False
      out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE    )
      return out_string.strip()






   def 		_lowerCamelCase  (					self     ,							_UpperCamelCase     ,							_UpperCamelCase = None    ):





      """simple docstring"""





      if not os.path.isdir(_SCREAMING_SNAKE_CASE    ):
         logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''    )
         return
      _lowercase     : Tuple     	=  os.path.join(
          _SCREAMING_SNAKE_CASE     ,							(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]    )

      if os.path.abspath(self.vocab_file    ) != os.path.abspath(_SCREAMING_SNAKE_CASE    ) and os.path.isfile(self.vocab_file    ):
         copyfile(self.vocab_file     ,							_SCREAMING_SNAKE_CASE    )
      elif not os.path.isfile(self.vocab_file    ):
         with open(_SCREAMING_SNAKE_CASE     ,							"wb"    ) as fi:
            _lowercase     : List[str]     	=  self.sp_model.serialized_model_proto()
            fi.write(_SCREAMING_SNAKE_CASE    )

      return (out_vocab_file,)












'''simple docstring'''





from math import factorial





def       __a      (  _UpperCamelCase:       int = 100       )		->					int:

     """simple docstring"""




     return sum(map(_UpperCamelCase   ,		str(factorial(_UpperCamelCase       )       )       )       )


if __name__ == "__main__":
   print(solution(int(input('''Enter the Number: ''').strip())))


