





'''simple docstring'''






import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


A_		:  Union[str, Any]		 =						get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
    from transformers.models.mbart.modeling_mbart import shift_tokens_right

A_		:  str		 =						250004
A_		:  str		 =						250020
@require_sentencepiece
@require_tokenizers
class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      MBartTokenizer
   lowerCamelCase__    							=      MBartTokenizerFast
   lowerCamelCase__    							=      True
   lowerCamelCase__    							=      True

   def 		__UpperCamelCase						(							self       ):
    super().setUp()

    # We have a SentencePiece fixture for testing
    snake_case__     :					Tuple    =  MBartTokenizer(__SCREAMING_SNAKE_CASE	,		keep_accents=__SCREAMING_SNAKE_CASE       )
    tokenizer.save_pretrained(self.tmpdirname       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Tuple    =  MBartTokenizer(__SCREAMING_SNAKE_CASE	,		keep_accents=__SCREAMING_SNAKE_CASE       )

    snake_case__     :					int    =  tokenizer.tokenize("""This is a test"""       )
    self.assertListEqual(__SCREAMING_SNAKE_CASE	,		["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]       )

    self.assertListEqual(
        tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE       )	,		[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]]	,		)

    snake_case__     :					Optional[int]    =  tokenizer.tokenize("""I was born in 92000, and this is falsé."""       )
    self.assertListEqual(
        __SCREAMING_SNAKE_CASE	,		[
            SPIECE_UNDERLINE + """I""",
            SPIECE_UNDERLINE + """was""",
            SPIECE_UNDERLINE + """b""",
            """or""",
            """n""",
            SPIECE_UNDERLINE + """in""",
            SPIECE_UNDERLINE + """""",
            """9""",
            """2""",
            """0""",
            """0""",
            """0""",
            """,""",
            SPIECE_UNDERLINE + """and""",
            SPIECE_UNDERLINE + """this""",
            SPIECE_UNDERLINE + """is""",
            SPIECE_UNDERLINE + """f""",
            """al""",
            """s""",
            """é""",
            """.""",
        ]	,		)
    snake_case__     :					Optional[int]    =  tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE       )
    self.assertListEqual(
        __SCREAMING_SNAKE_CASE	,		[
            value + tokenizer.fairseq_offset
            for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
            #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
        ]	,		)

    snake_case__     :					Union[str, Any]    =  tokenizer.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE       )
    self.assertListEqual(
        __SCREAMING_SNAKE_CASE	,		[
            SPIECE_UNDERLINE + """I""",
            SPIECE_UNDERLINE + """was""",
            SPIECE_UNDERLINE + """b""",
            """or""",
            """n""",
            SPIECE_UNDERLINE + """in""",
            SPIECE_UNDERLINE + """""",
            """<unk>""",
            """2""",
            """0""",
            """0""",
            """0""",
            """,""",
            SPIECE_UNDERLINE + """and""",
            SPIECE_UNDERLINE + """this""",
            SPIECE_UNDERLINE + """is""",
            SPIECE_UNDERLINE + """f""",
            """al""",
            """s""",
            """<unk>""",
            """.""",
        ]	,		)


   def 		__UpperCamelCase						(							self       ):
    if not self.test_slow_tokenizer:
     # as we don't have a slow version, we can't compare the outputs between slow and fast versions
     return

    snake_case__     :					Optional[int]    =  (self.rust_tokenizer_class, """hf-internal-testing/tiny-random-mbart""", {})
    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"       ):
      snake_case__     :					Optional[Any]    =  self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE	,		**__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Dict    =  self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE	,		**__SCREAMING_SNAKE_CASE       )

      snake_case__     :					List[str]    =  tempfile.mkdtemp()

      snake_case__     :					int    =  tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Dict    =  tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE       )

      # Checks it save with the same files + the tokenizer.json file for the fast one
      self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files       )       )
      snake_case__     :					List[str]    =  tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f       )
      self.assertSequenceEqual(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )

      # Checks everything loads correctly in the same way
      snake_case__     :					Tuple    =  tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Union[str, Any]    =  tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE       )

      # Check special tokens are set accordingly on Rust and Python
      for key in tokenizer_pp.special_tokens_map:
       self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )       )
       # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
       # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

      shutil.rmtree(__SCREAMING_SNAKE_CASE       )

      # Save tokenizer rust, legacy_format=True
      snake_case__     :					Any    =  tempfile.mkdtemp()

      snake_case__     :					Optional[int]    =  tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE	,		legacy_format=__SCREAMING_SNAKE_CASE       )
      snake_case__     :					int    =  tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE       )

      # Checks it save with the same files
      self.assertSequenceEqual(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )

      # Checks everything loads correctly in the same way
      snake_case__     :					List[Any]    =  tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Dict    =  tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE       )

      # Check special tokens are set accordingly on Rust and Python
      for key in tokenizer_pp.special_tokens_map:
       self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )       )

      shutil.rmtree(__SCREAMING_SNAKE_CASE       )

      # Save tokenizer rust, legacy_format=False
      snake_case__     :					Dict    =  tempfile.mkdtemp()

      snake_case__     :					Union[str, Any]    =  tokenizer_r.save_pretrained(__SCREAMING_SNAKE_CASE	,		legacy_format=__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Optional[int]    =  tokenizer_p.save_pretrained(__SCREAMING_SNAKE_CASE       )

      # Checks it saved the tokenizer.json file
      self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files       )       )

      # Checks everything loads correctly in the same way
      snake_case__     :					Dict    =  tokenizer_r.from_pretrained(__SCREAMING_SNAKE_CASE       )
      snake_case__     :					Any    =  tokenizer_p.from_pretrained(__SCREAMING_SNAKE_CASE       )

      # Check special tokens are set accordingly on Rust and Python
      for key in tokenizer_pp.special_tokens_map:
       self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )       )

      shutil.rmtree(__SCREAMING_SNAKE_CASE       )



@require_torch
@require_sentencepiece
@require_tokenizers
class 					__snake_case  (					unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      '''facebook/mbart-large-en-ro'''
   lowerCamelCase__    							=      [
       ''' UN Chief Says There Is No Military Solution in Syria''',
       ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''',
   ]
   lowerCamelCase__    							=      [
       '''Şeful ONU declară că nu există o soluţie militară în Siria''',
       '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'''
       ''' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'''
       ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
   ]
   lowerCamelCase__    							=      [8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2, EN_CODE]

   @classmethod
   def 		__UpperCamelCase						(							cls       ):
    snake_case__     :					MBartTokenizer    =  MBartTokenizer.from_pretrained(
        cls.checkpoint_name	,		src_lang="""en_XX"""	,		tgt_lang="""ro_RO"""       )
    snake_case__     :					Any    =  1
    return cls

   def 		__UpperCamelCase						(							self       ):
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""]	,		2_5_0_0_0_1       )
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""]	,		2_5_0_0_0_4       )
    self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""]	,		2_5_0_0_2_0       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Tuple    =  self.tokenizer.batch_encode_plus(self.src_text       ).input_ids[0]
    self.assertListEqual(self.expected_src_tokens	,		__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    self.assertIn(__SCREAMING_SNAKE_CASE	,		self.tokenizer.all_special_ids       )
    snake_case__     :					List[str]    =  [RO_CODE, 8_8_4, 9_0_1_9, 9_6, 9, 9_1_6, 8_6_7_9_2, 3_6, 1_8_7_4_3, 1_5_5_9_6, 5, 2]
    snake_case__     :					List[Any]    =  self.tokenizer.decode(__SCREAMING_SNAKE_CASE	,		skip_special_tokens=__SCREAMING_SNAKE_CASE       )
    snake_case__     :					Dict    =  self.tokenizer.decode(generated_ids[1:]	,		skip_special_tokens=__SCREAMING_SNAKE_CASE       )
    self.assertEqual(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )
    self.assertNotIn(self.tokenizer.eos_token	,		__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Dict    =  ["""this is gunna be a long sentence """ * 2_0]
    assert isinstance(src_text[0]	,		__SCREAMING_SNAKE_CASE       )
    snake_case__     :					Tuple    =  1_0
    snake_case__     :					int    =  self.tokenizer(__SCREAMING_SNAKE_CASE	,		max_length=__SCREAMING_SNAKE_CASE	,		truncation=__SCREAMING_SNAKE_CASE       ).input_ids[0]
    self.assertEqual(ids[-2]	,		2       )
    self.assertEqual(ids[-1]	,		__SCREAMING_SNAKE_CASE       )
    self.assertEqual(len(__SCREAMING_SNAKE_CASE       )	,		__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]       )	,		[2_5_0_0_2_6, 2_5_0_0_0_1]       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Union[str, Any]    =  tempfile.mkdtemp()
    snake_case__     :					Dict    =  self.tokenizer.fairseq_tokens_to_ids
    self.tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE       )
    snake_case__     :					Any    =  MBartTokenizer.from_pretrained(__SCREAMING_SNAKE_CASE       )
    self.assertDictEqual(new_tok.fairseq_tokens_to_ids	,		__SCREAMING_SNAKE_CASE       )

   @require_torch
   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Tuple    =  self.tokenizer(self.src_text	,		text_target=self.tgt_text	,		padding=__SCREAMING_SNAKE_CASE	,		return_tensors="""pt"""       )
    snake_case__     :					int    =  shift_tokens_right(batch["""labels"""]	,		self.tokenizer.pad_token_id       )

    # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
    assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE]
    assert batch.decoder_input_ids[1][0].tolist() == RO_CODE
    assert batch.decoder_input_ids[1][-1] == 2
    assert batch.labels[1][-2:].tolist() == [2, RO_CODE]

   @require_torch
   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  self.tokenizer(
        self.src_text	,		text_target=self.tgt_text	,		padding=__SCREAMING_SNAKE_CASE	,		truncation=__SCREAMING_SNAKE_CASE	,		max_length=len(self.expected_src_tokens       )	,		return_tensors="""pt"""	,		)

    snake_case__     :					List[str]    =  shift_tokens_right(batch["""labels"""]	,		self.tokenizer.pad_token_id       )

    self.assertIsInstance(__SCREAMING_SNAKE_CASE	,		__SCREAMING_SNAKE_CASE       )

    self.assertEqual((2, 1_4)	,		batch.input_ids.shape       )
    self.assertEqual((2, 1_4)	,		batch.attention_mask.shape       )
    snake_case__     :					Tuple    =  batch.input_ids.tolist()[0]
    self.assertListEqual(self.expected_src_tokens	,		__SCREAMING_SNAKE_CASE       )
    self.assertEqual(2	,		batch.decoder_input_ids[0, -1]       )  # EOS
    # Test that special tokens are reset
    self.assertEqual(self.tokenizer.prefix_tokens	,		[]       )
    self.assertEqual(self.tokenizer.suffix_tokens	,		[self.tokenizer.eos_token_id, EN_CODE]       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  self.tokenizer(self.src_text	,		padding=__SCREAMING_SNAKE_CASE	,		truncation=__SCREAMING_SNAKE_CASE	,		max_length=3	,		return_tensors="""pt"""       )
    snake_case__     :					Optional[int]    =  self.tokenizer(
        text_target=self.tgt_text	,		padding=__SCREAMING_SNAKE_CASE	,		truncation=__SCREAMING_SNAKE_CASE	,		max_length=1_0	,		return_tensors="""pt"""       )
    snake_case__     :					str    =  targets["""input_ids"""]
    snake_case__     :					Optional[Any]    =  shift_tokens_right(__SCREAMING_SNAKE_CASE	,		self.tokenizer.pad_token_id       )

    self.assertEqual(batch.input_ids.shape[1]	,		3       )
    self.assertEqual(batch.decoder_input_ids.shape[1]	,		1_0       )


   @require_torch
   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Tuple    =  self.tokenizer._build_translation_inputs(
        """A test"""	,		return_tensors="""pt"""	,		src_lang="""en_XX"""	,		tgt_lang="""ar_AR"""       )

    self.assertEqual(
        nested_simplify(__SCREAMING_SNAKE_CASE       )	,		{
            # A, test, EOS, en_XX
            """input_ids""": [[6_2, 3_0_3_4, 2, 2_5_0_0_0_4]],
            """attention_mask""": [[1, 1, 1, 1]],
            # ar_AR
            """forced_bos_token_id""": 2_5_0_0_0_1,
        }	,		)










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


