
'''simple docstring'''

import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
	from .tokenization_albert import AlbertTokenizer
else:
	_UpperCAmelCase :   Optional[int]			    =	None

_UpperCAmelCase :   Dict			    =	logging.get_logger(__name__)
_UpperCAmelCase :   Dict			    =	{"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}

_UpperCAmelCase :   int			    =	{
    "vocab_file": {
        "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/spiece.model",
        "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/spiece.model",
        "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model",
        "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model",
        "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/spiece.model",
        "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/spiece.model",
        "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model",
        "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model",
    },
    "tokenizer_file": {
        "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/tokenizer.json",
        "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/tokenizer.json",
        "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/tokenizer.json",
        "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/tokenizer.json",
        "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/tokenizer.json",
        "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/tokenizer.json",
        "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/tokenizer.json",
        "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/tokenizer.json",
    },
}

_UpperCAmelCase :   Any			    =	{
    "albert-base-v1": 512,
    "albert-large-v1": 512,
    "albert-xlarge-v1": 512,
    "albert-xxlarge-v1": 512,
    "albert-base-v2": 512,
    "albert-large-v2": 512,
    "albert-xlarge-v2": 512,
    "albert-xxlarge-v2": 512,
}

_UpperCAmelCase :   Optional[int]			    =	"▁"

class       UpperCAmelCase					(       lowercase_			):





		"""simple docstring"""





		A__	: List[Any]    =     VOCAB_FILES_NAMES
		A__	: Tuple    =     PRETRAINED_VOCAB_FILES_MAP
		A__	: Tuple    =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		A__	: Any    =     AlbertTokenizer
		def __init__(     self	,       _snake_case=None	,       _snake_case=None	,       _snake_case=True	,       _snake_case=True	,       _snake_case=False	,       _snake_case="[CLS]"	,       _snake_case="[SEP]"	,       _snake_case="<unk>"	,       _snake_case="[SEP]"	,       _snake_case="<pad>"	,       _snake_case="[CLS]"	,       _snake_case="[MASK]"	,       **_snake_case	,       )					->     Tuple:
				# Mask token behave like a normal word, i.e. include the space before it and
				# is included in the raw text, there should be a match in a non-normalized sentence.
				_UpperCamelCase							:			str     =   (
				    AddedToken(_lowercase	,       lstrip=_lowercase	,       rstrip=_lowercase	,       normalized=_lowercase  )
				    if isinstance(_lowercase	,       _lowercase  )
				    else mask_token
				)

				super().__init__(
				    _lowercase	,       tokenizer_file=_lowercase	,       do_lower_case=_lowercase	,       remove_space=_lowercase	,       keep_accents=_lowercase	,       bos_token=_lowercase	,       eos_token=_lowercase	,       unk_token=_lowercase	,       sep_token=_lowercase	,       pad_token=_lowercase	,       cls_token=_lowercase	,       mask_token=_lowercase	,       **_lowercase	,       )

				_UpperCamelCase							:			int     =   do_lower_case
				_UpperCamelCase							:			Union[str, Any]     =   remove_space
				_UpperCamelCase							:			Optional[Any]     =   keep_accents
				_UpperCamelCase							:			Union[str, Any]     =   vocab_file
				_UpperCamelCase							:			List[str]     =   False if not self.vocab_file else True
		def _lowercase	(     self	,       _snake_case	,       _snake_case = None  )					->     List[int]:
				_UpperCamelCase							:			Optional[int]     =   [self.sep_token_id]
				_UpperCamelCase							:			Optional[int]     =   [self.cls_token_id]
				if token_ids_a is None:
						return cls + token_ids_a + sep
				return cls + token_ids_a + sep + token_ids_a + sep
		def _lowercase	(     self	,       _snake_case	,       _snake_case = None  )					->     List[int]:
				_UpperCamelCase							:			Tuple     =   [self.sep_token_id]
				_UpperCamelCase							:			Optional[Any]     =   [self.cls_token_id]

				if token_ids_a is None:
						return len(cls + token_ids_a + sep  ) * [0]
				return len(cls + token_ids_a + sep  ) * [0] + len(token_ids_a + sep  ) * [1]




		def _lowercase	(     self	,       _snake_case	,       _snake_case = None  )					->     Tuple[str]:
				if not self.can_save_slow_tokenizer:
						raise ValueError(
						    '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
						    '''tokenizer.'''  )

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

				if os.path.abspath(self.vocab_file  ) != os.path.abspath(_lowercase  ):
						copyfile(self.vocab_file	,       _lowercase  )

				return (out_vocab_file,)








'''simple docstring'''

from math import factorial




def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 100   )      -> int:
							return sum(map(lowerCAmelCase__		,str(factorial(lowerCAmelCase__   )   )   )   )


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





