




'''simple docstring'''





import json
import os
import unittest

from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES, BioGptTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin

class   _a							(		__lowerCAmelCase   ,   unittest.TestCase				):
     SCREAMING_SNAKE_CASE_				:       Any       							=		BioGptTokenizer
     SCREAMING_SNAKE_CASE_				:       Tuple       							=		False






     def 							_lowercase      (					self       )				->     Union[str, Any]:
          super().setUp()

          # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
          _snake_case				= [
              "l",
              "o",
              "w",
              "e",
              "r",
              "s",
              "t",
              "i",
              "d",
              "n",
              "w</w>",
              "r</w>",
              "t</w>",
              "lo",
              "low",
              "er</w>",
              "low</w>",
              "lowest</w>",
              "newer</w>",
              "wider</w>",
              "<unk>",
          ]
          _snake_case				= dict(zip(_SCREAMING_SNAKE_CASE   ,range(len(_SCREAMING_SNAKE_CASE       )       )       )       )
          _snake_case				= ["l o 123", "lo w 1456", "e r</w> 1789", ""]

          _snake_case				= os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES["vocab_file"]       )
          _snake_case				= os.path.join(self.tmpdirname   ,VOCAB_FILES_NAMES["merges_file"]       )
          with open(self.vocab_file   ,"w"       ) as fp:
               fp.write(json.dumps(_SCREAMING_SNAKE_CASE       )       )
          with open(self.merges_file   ,"w"       ) as fp:
               fp.write("\n".join(_SCREAMING_SNAKE_CASE       )       )






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE       )				->     Tuple:
          _snake_case				= "lower newer"
          _snake_case				= "lower newer"
          return input_text, output_text






     def 							_lowercase      (					self       )				->     List[Any]:
          _snake_case				= BioGptTokenizer(self.vocab_file   ,self.merges_file       )

          _snake_case				= "lower"
          _snake_case				= ["low", "er</w>"]
          _snake_case				= tokenizer.tokenize(_SCREAMING_SNAKE_CASE       )
          self.assertListEqual(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          _snake_case				= tokens + ["<unk>"]
          _snake_case				= [14, 15, 20]
          self.assertListEqual(tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE       )   ,_SCREAMING_SNAKE_CASE       )






     @slow
     def 							_lowercase      (					self       )				->     Dict:
          _snake_case				= BioGptTokenizer.from_pretrained("microsoft/biogpt"       )

          _snake_case				= tokenizer.encode("sequence builders"   ,add_special_tokens=_SCREAMING_SNAKE_CASE       )
          _snake_case				= tokenizer.encode("multi-sequence build"   ,add_special_tokens=_SCREAMING_SNAKE_CASE       )

          _snake_case				= tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE       )
          _snake_case				= tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )

          self.assertTrue(encoded_sentence == [2] + text       )
          self.assertTrue(encoded_pair == [2] + text + [2] + text_a       )








'''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())))


