import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    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


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


if is_torch_available():
       from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

lowerCAmelCase_ : List[str]						  =      256_047
lowerCAmelCase_ : Optional[int]						  =      256_145





@require_sentencepiece
@require_tokenizers
class 							lowercase						(						__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=NllbTokenizer
   lowerCamelCase_    					=NllbTokenizerFast
   lowerCamelCase_    					=True
   lowerCamelCase_    					=True
   lowerCamelCase_    					={}


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Optional[int]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         lowercase_     =      NllbTokenizer(__lowerCAmelCase   ,		keep_accents=__lowerCAmelCase)
         tokenizer.save_pretrained(self.tmpdirname)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[str]:
         lowercase_     =      NllbTokenizer(__lowerCAmelCase   ,		keep_accents=__lowerCAmelCase)

         lowercase_     =      tokenizer.tokenize("This is a test")
         self.assertListEqual(__lowerCAmelCase   ,		["▁This", "▁is", "▁a", "▁t", "est"])

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(__lowerCAmelCase)   ,		[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]   ,		)

         lowercase_     =      tokenizer.tokenize("I was born in 92000, and this is falsé.")
         self.assertListEqual(
             __lowerCAmelCase   ,		[
                 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",
                 "é",
                 ".",
             ]   ,		)
         lowercase_     =      tokenizer.convert_tokens_to_ids(__lowerCAmelCase)
         self.assertListEqual(
             __lowerCAmelCase   ,		[
                 value + tokenizer.fairseq_offset
                 for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
             ]   ,		)

         lowercase_     =      tokenizer.convert_ids_to_tokens(__lowerCAmelCase)
         self.assertListEqual(
             __lowerCAmelCase   ,		[
                 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				:	str)      ->					Optional[int]:
         lowercase_     =      (self.rust_tokenizer_class, "hf-internal-testing/tiny-random-nllb", {})
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'):
                     lowercase_     =      self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase   ,		**__lowerCAmelCase)
                     lowercase_     =      self.tokenizer_class.from_pretrained(__lowerCAmelCase   ,		**__lowerCAmelCase)

                     lowercase_     =      tempfile.mkdtemp()

                     lowercase_     =      tokenizer_r.save_pretrained(__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.save_pretrained(__lowerCAmelCase)

                     # 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))
                     lowercase_     =      tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f)
                     self.assertSequenceEqual(__lowerCAmelCase   ,		__lowerCAmelCase)

                     # Checks everything loads correctly in the same way
                     lowercase_     =      tokenizer_r.from_pretrained(__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.from_pretrained(__lowerCAmelCase)

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

                     shutil.rmtree(__lowerCAmelCase)

                     # Save tokenizer rust, legacy_format=True
                     lowercase_     =      tempfile.mkdtemp()

                     lowercase_     =      tokenizer_r.save_pretrained(__lowerCAmelCase   ,		legacy_format=__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.save_pretrained(__lowerCAmelCase)

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

                     # Checks everything loads correctly in the same way
                     lowercase_     =      tokenizer_r.from_pretrained(__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.from_pretrained(__lowerCAmelCase)

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

                     shutil.rmtree(__lowerCAmelCase)

                     # Save tokenizer rust, legacy_format=False
                     lowercase_     =      tempfile.mkdtemp()

                     lowercase_     =      tokenizer_r.save_pretrained(__lowerCAmelCase   ,		legacy_format=__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.save_pretrained(__lowerCAmelCase)

                     # 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
                     lowercase_     =      tokenizer_r.from_pretrained(__lowerCAmelCase)
                     lowercase_     =      tokenizer_p.from_pretrained(__lowerCAmelCase)

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

                     shutil.rmtree(__lowerCAmelCase)


   @require_torch
   def __UpperCAmelCase       (   self				:	List[str])      ->					List[str]:
         if not self.test_seqaseq:
               return

         lowercase_     =      self.get_tokenizers()
         for tokenizer in tokenizers:
               with self.subTest(F'{tokenizer.__class__.__name__}'):
                     # Longer text that will definitely require truncation.
                     lowercase_     =      [
                         " 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.",
                     ]
                     lowercase_     =      [
                         "Ş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.",
                     ]
                     try:
                           lowercase_     =      tokenizer.prepare_seqaseq_batch(
                               src_texts=__lowerCAmelCase   ,		tgt_texts=__lowerCAmelCase   ,		max_length=3   ,		max_target_length=10   ,		return_tensors="pt"   ,		src_lang="eng_Latn"   ,		tgt_lang="ron_Latn"   ,		)
                     except NotImplementedError:
                           return
                     self.assertEqual(batch.input_ids.shape[1]   ,		3)
                     self.assertEqual(batch.labels.shape[1]   ,		10)
                     # max_target_length will default to max_length if not specified
                     lowercase_     =      tokenizer.prepare_seqaseq_batch(
                         __lowerCAmelCase   ,		tgt_texts=__lowerCAmelCase   ,		max_length=3   ,		return_tensors="pt")
                     self.assertEqual(batch.input_ids.shape[1]   ,		3)
                     self.assertEqual(batch.labels.shape[1]   ,		3)

                     lowercase_     =      tokenizer.prepare_seqaseq_batch(
                         src_texts=__lowerCAmelCase   ,		max_length=3   ,		max_target_length=10   ,		return_tensors="pt")
                     self.assertEqual(batch_encoder_only.input_ids.shape[1]   ,		3)
                     self.assertEqual(batch_encoder_only.attention_mask.shape[1]   ,		3)
                     self.assertNotIn("decoder_input_ids"   ,		__lowerCAmelCase)


   @unittest.skip("Unfortunately way too slow to build a BPE with SentencePiece.")
   def __UpperCAmelCase       (   self				:	List[str])      ->					Dict:
         pass


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					List[str]:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'):
                     lowercase_     =      [AddedToken("<special>"   ,		lstrip=__lowerCAmelCase)]

                     lowercase_     =      self.rust_tokenizer_class.from_pretrained(
                         __lowerCAmelCase   ,		additional_special_tokens=__lowerCAmelCase   ,		**__lowerCAmelCase)
                     lowercase_     =      tokenizer_r.encode("Hey this is a <special> token")

                     lowercase_     =      tokenizer_r.encode("<special>"   ,		add_special_tokens=__lowerCAmelCase)[0]

                     self.assertTrue(special_token_id in r_output)

                     if self.test_slow_tokenizer:
                           lowercase_     =      self.rust_tokenizer_class.from_pretrained(
                               __lowerCAmelCase   ,		additional_special_tokens=__lowerCAmelCase   ,		**__lowerCAmelCase   ,		)
                           lowercase_     =      self.tokenizer_class.from_pretrained(
                               __lowerCAmelCase   ,		additional_special_tokens=__lowerCAmelCase   ,		**__lowerCAmelCase)

                           lowercase_     =      tokenizer_p.encode("Hey this is a <special> token")

                           lowercase_     =      tokenizer_cr.encode("Hey this is a <special> token")

                           self.assertEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
                           self.assertEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
                           self.assertTrue(special_token_id in p_output)
                           self.assertTrue(special_token_id in cr_output)





@require_torch
@require_sentencepiece
@require_tokenizers
class 							lowercase						(						unittest.TestCase ):
   lowerCamelCase_    					='facebook/nllb-200-distilled-600M'
   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_    					=[
       2_5_6_0_4_7,
       1_6_2_9_7,
       1_3_4_4_0_8,
       8_1_6_5,
       2_4_8_0_6_6,
       1_4_7_3_4,
       9_5_0,
       1_1_3_5,
       1_0_5_7_2_1,
       3_5_7_3,
       8_3,
       2_7_3_5_2,
       1_0_8,
       4_9_4_8_6,
       2,
   ]


   @classmethod
   def __UpperCAmelCase       (   cls				:	List[str])      ->					List[Any]:
         lowercase_     =      NllbTokenizer.from_pretrained(
             cls.checkpoint_name   ,		src_lang="eng_Latn"   ,		tgt_lang="ron_Latn")
         lowercase_     =      1
         return cls


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Arab"]   ,		25_6001)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Latn"]   ,		25_6002)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["fra_Latn"]   ,		25_6057)


   def __UpperCAmelCase       (   self				:	str)      ->					Optional[int]:
         lowercase_     =      self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
         self.assertListEqual(self.expected_src_tokens   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Optional[Any]:
         self.assertIn(__lowerCAmelCase   ,		self.tokenizer.all_special_ids)
         # fmt: off
         lowercase_     =      [RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
         # fmt: on

         lowercase_     =      self.tokenizer.decode(__lowerCAmelCase   ,		skip_special_tokens=__lowerCAmelCase)
         lowercase_     =      self.tokenizer.decode(generated_ids[1:]   ,		skip_special_tokens=__lowerCAmelCase)
         self.assertEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         self.assertNotIn(self.tokenizer.eos_token   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	str)      ->					Tuple:
         lowercase_     =      ["this is gunna be a long sentence " * 20]
         assert isinstance(src_text[0]   ,		__lowerCAmelCase)
         lowercase_     =      10
         lowercase_     =      self.tokenizer(__lowerCAmelCase   ,		max_length=__lowerCAmelCase   ,		truncation=__lowerCAmelCase).input_ids[0]
         self.assertEqual(ids[-1]   ,		2)
         self.assertEqual(ids[0]   ,		__lowerCAmelCase)
         self.assertEqual(len(__lowerCAmelCase)   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	str)      ->					str:
         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"])   ,		[25_6203, 3])


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					List[str]:
         lowercase_     =      tempfile.mkdtemp()
         lowercase_     =      self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(__lowerCAmelCase)
         lowercase_     =      NllbTokenizer.from_pretrained(__lowerCAmelCase)
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids   ,		__lowerCAmelCase)


   @require_torch
   def __UpperCAmelCase       (   self				:	List[Any])      ->					str:
         lowercase_     =      self.tokenizer(
             self.src_text   ,		text_target=self.tgt_text   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		max_length=len(self.expected_src_tokens)   ,		return_tensors="pt"   ,		)
         lowercase_     =      shift_tokens_right(
             batch["labels"]   ,		self.tokenizer.pad_token_id   ,		self.tokenizer.lang_code_to_id["ron_Latn"])

         self.assertIsInstance(__lowerCAmelCase   ,		__lowerCAmelCase)

         self.assertEqual((2, 15)   ,		batch.input_ids.shape)
         self.assertEqual((2, 15)   ,		batch.attention_mask.shape)
         lowercase_     =      batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens   ,		__lowerCAmelCase)
         self.assertEqual(__lowerCAmelCase   ,		batch.decoder_input_ids[0, 0])  # EOS
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens   ,		[EN_CODE])
         self.assertEqual(self.tokenizer.suffix_tokens   ,		[self.tokenizer.eos_token_id])


   def __UpperCAmelCase       (   self				:	str)      ->					List[Any]:
         lowercase_     =      self.tokenizer(self.src_text   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		max_length=3   ,		return_tensors="pt")
         lowercase_     =      self.tokenizer(
             text_target=self.tgt_text   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		max_length=10   ,		return_tensors="pt")
         lowercase_     =      targets["input_ids"]
         lowercase_     =      shift_tokens_right(
             __lowerCAmelCase   ,		self.tokenizer.pad_token_id   ,		decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]   ,		)

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


   @require_torch
   def __UpperCAmelCase       (   self				:	str)      ->					Any:
         lowercase_     =      self.tokenizer._build_translation_inputs(
             "A test"   ,		return_tensors="pt"   ,		src_lang="eng_Latn"   ,		tgt_lang="fra_Latn")

         self.assertEqual(
             nested_simplify(__lowerCAmelCase)   ,		{
                 # A, test, EOS, en_XX
                 "input_ids": [[25_6047, 70, 7356, 2]],
                 "attention_mask": [[1, 1, 1, 1]],
                 # ar_AR
                 "forced_bos_token_id": 25_6057,
             }   ,		)


   @require_torch
   def __UpperCAmelCase       (   self				:	List[str])      ->					Tuple:
         lowercase_     =      True
         lowercase_     =      self.tokenizer(
             "UN Chief says there is no military solution in Syria"   ,		src_lang="eng_Latn"   ,		tgt_lang="fra_Latn")
         self.assertEqual(
             inputs.input_ids   ,		[1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047])

         lowercase_     =      False
         lowercase_     =      self.tokenizer(
             "UN Chief says there is no military solution in Syria"   ,		src_lang="eng_Latn"   ,		tgt_lang="fra_Latn")
         self.assertEqual(
             inputs.input_ids   ,		[25_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2])







'''simple docstring'''

from __future__ import annotations


def __a (	__lowerCamelCase			:						int | str				)	->							bool:
      '''simple docstring'''


      lowercase_     =      str(__lowerCamelCase				)
      return n == n[::-1]


def __a (	__lowerCamelCase			:						int = 1_000_000				)	->							Optional[int]:
      '''simple docstring'''


      lowercase_     =      0

      for i in range(1 ,		__lowerCamelCase				):
            if is_palindrome(__lowerCamelCase				) and is_palindrome(bin(__lowerCamelCase				).split("b"				)[1]				):
                  total += i
      return total


if __name__ == "__main__":
       print(solution(int(str(input().strip()))))






