

from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_herbert import HerbertTokenizer


lowerCAmelCase__	   = logging.get_logger(__name__)

lowerCAmelCase__	   = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

lowerCAmelCase__	   = {
    """vocab_file""": {
        """allegro/herbert-base-cased""": """https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json"""
    },
    """merges_file""": {
        """allegro/herbert-base-cased""": """https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt"""
    },
}

lowerCAmelCase__	   = {"""allegro/herbert-base-cased""": 5_1_4}
lowerCAmelCase__	   = {}

class 					a__						(					lowercase__			):
			"""simple docstring"""







			__lowerCamelCase        =       VOCAB_FILES_NAMES
			__lowerCamelCase        =       PRETRAINED_VOCAB_FILES_MAP
			__lowerCamelCase        =       PRETRAINED_INIT_CONFIGURATION
			__lowerCamelCase        =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__lowerCamelCase        =       HerbertTokenizer


			def __init__(    self      ,      lowercase=None      ,      lowercase=None      ,      lowercase=None      ,      lowercase="<s>"      ,      lowercase="<unk>"      ,      lowercase="<pad>"      ,      lowercase="<mask>"      ,      lowercase="</s>"      ,      **lowercase      ,      )  ->						Any:
							'''simple docstring'''






							super().__init__(
							    lowercase      ,      lowercase      ,      tokenizer_file=lowercase      ,      cls_token=lowercase      ,      unk_token=lowercase      ,      pad_token=lowercase      ,      mask_token=lowercase      ,      sep_token=lowercase      ,      **lowercase      ,      )


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase = None       )  ->						Optional[int]:
							'''simple docstring'''






							A__        =			[self.cls_token_id]
							A__        =			[self.sep_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      UpperCamelCase		(    self      ,      lowercase      ,      lowercase = None      ,      lowercase = False       )  ->						Any:
							'''simple docstring'''






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

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


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase = None       )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			[self.sep_token_id]
							A__        =			[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      UpperCamelCase		(    self      ,      lowercase      ,      lowercase = None       )  ->						str:
							'''simple docstring'''






							A__        =			self._tokenizer.model.save(lowercase      ,      name=lowercase       )
							return tuple(lowercase       )


from math import factorial



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int = 1_0_0      )			->      int:




				'''simple docstring'''





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


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

