






"""simple docstring"""




import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase							       =    get_tests_dir("""fixtures/test_sentencepiece.model""")

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

UpperCamelCase							       =    250_004
UpperCamelCase							       =    250_020




@require_sentencepiece
@require_tokenizers
class    lowercase_    (_UpperCAmelCase,    unittest.TestCase     ):
      A__	:		Dict       			=				MBartaaTokenizer
      A__	:		List[str]       			=				MBartaaTokenizerFast
      A__	:		Optional[int]       			=				True
      A__	:		List[Any]       			=				True






      def 			lowerCamelCase__    (    self	)	->Any:







        '''simple docstring'''


        super().setUp()

        # We have a SentencePiece fixture for testing
        _a							=	MBartaaTokenizer(a_     ,     src_lang="en_XX"     ,     tgt_lang="ro_RO"     ,     keep_accents=a_	)
        tokenizer.save_pretrained(self.tmpdirname	)






      def 			lowerCamelCase__    (    self	)	->Dict:







        '''simple docstring'''


        _a							=	"<s>"
        _a							=	0

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(a_	)     ,     a_	)
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(a_	)     ,     a_	)






      def 			lowerCamelCase__    (    self	)	->List[str]:







        '''simple docstring'''


        _a							=	list(self.get_tokenizer().get_vocab().keys()	)

        self.assertEqual(vocab_keys[0]     ,     "<s>"	)
        self.assertEqual(vocab_keys[1]     ,     "<pad>"	)
        self.assertEqual(vocab_keys[-1]     ,     "<mask>"	)
        self.assertEqual(len(a_	)     ,     1_0_5_4	)






      def 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        self.assertEqual(self.get_tokenizer().vocab_size     ,     1_0_5_4	)






      def 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        _a							=	MBartaaTokenizer(a_     ,     src_lang="en_XX"     ,     tgt_lang="ro_RO"     ,     keep_accents=a_	)

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

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

        _a							=	tokenizer.tokenize("I was born in 92000, and this is falsé."	)
        self.assertListEqual(
            a_     ,     [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", "é", "."]     ,     )
        _a							=	tokenizer.convert_tokens_to_ids(a_	)
        self.assertListEqual(
            a_     ,     [
                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]
            ]     ,     )

        _a							=	tokenizer.convert_ids_to_tokens(a_	)
        self.assertListEqual(
            a_     ,     [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>", "."]     ,     )






      @slow
      def 			lowerCamelCase__    (    self	)	->Dict:







        '''simple docstring'''


        _a							=	{"input_ids": [[2_5_0_0_0_4, 1_1_0_6_2, 8_2_7_7_2, 7, 1_5, 8_2_7_7_2, 5_3_8, 5_1_5_2_9, 2_3_7, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 2_1_5_1_7_5, 1_3_1_4, 1_3_6, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 5_6_3_5_9, 4_2, 1_2_2_0_0_9, 9, 1_6_4_6_6, 1_6, 8_7_3_4_4, 4_5_3_7, 9, 4_7_1_7, 7_8_3_8_1, 6, 1_5_9_9_5_8, 7, 1_5, 2_4_4_8_0, 6_1_8, 4, 5_2_7, 2_2_6_9_3, 5_4_2_8, 4, 2_7_7_7, 2_4_4_8_0, 9_8_7_4, 4, 4_3_5_2_3, 5_9_4, 4, 8_0_3, 1_8_3_9_2, 3_3_1_8_9, 1_8, 4, 4_3_5_2_3, 2_4_4_4_7, 1_2_3_9_9, 1_0_0, 2_4_9_5_5, 8_3_6_5_8, 9_6_2_6, 1_4_4_0_5_7, 1_5, 8_3_9, 2_2_3_3_5, 1_6, 1_3_6, 2_4_9_5_5, 8_3_6_5_8, 8_3_4_7_9, 1_5, 3_9_1_0_2, 7_2_4, 1_6, 6_7_8, 6_4_5, 2_7_8_9, 1_3_2_8, 4_5_8_9, 4_2, 1_2_2_0_0_9, 1_1_5_7_7_4, 2_3, 8_0_5, 1_3_2_8, 4_6_8_7_6, 7, 1_3_6, 5_3_8_9_4, 1_9_4_0, 4_2_2_2_7, 4_1_1_5_9, 1_7_7_2_1, 8_2_3, 4_2_5, 4, 2_7_5_1_2, 9_8_7_2_2, 2_0_6, 1_3_6, 5_5_3_1, 4_9_7_0, 9_1_9, 1_7_3_3_6, 5, 2], [2_5_0_0_0_4, 2_0_0_8_0, 6_1_8, 8_3, 8_2_7_7_5, 4_7, 4_7_9, 9, 1_5_1_7, 7_3, 5_3_8_9_4, 3_3_3, 8_0_5_8_1, 1_1_0_1_1_7, 1_8_8_1_1, 5_2_5_6, 1_2_9_5, 5_1, 1_5_2_5_2_6, 2_9_7, 7_9_8_6, 3_9_0, 1_2_4_4_1_6, 5_3_8, 3_5_4_3_1, 2_1_4, 9_8, 1_5_0_4_4, 2_5_7_3_7, 1_3_6, 7_1_0_8, 4_3_7_0_1, 2_3, 7_5_6, 1_3_5_3_5_5, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2_5_0_0_0_4, 5_8_1, 6_3_7_7_3, 1_1_9_4_5_5, 6, 1_4_7_7_9_7, 8_8_2_0_3, 7, 6_4_5, 7_0, 2_1, 3_2_8_5, 1_0_2_6_9, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=a_     ,     model_name="facebook/mbart-large-50"     ,     revision="d3913889c59cd5c9e456b269c376325eabad57e2"     ,     )






      def 			lowerCamelCase__    (    self	)	->Dict:







        '''simple docstring'''


        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

        _a							=	(self.rust_tokenizer_class, "hf-internal-testing/tiny-random-mbart50", {})
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''	):
            _a							=	self.rust_tokenizer_class.from_pretrained(a_     ,     **a_	)
            _a							=	self.tokenizer_class.from_pretrained(a_     ,     **a_	)

            _a							=	tempfile.mkdtemp()

            _a							=	tokenizer_r.save_pretrained(a_	)
            _a							=	tokenizer_p.save_pretrained(a_	)

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

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

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

            shutil.rmtree(a_	)

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

            _a							=	tokenizer_r.save_pretrained(a_     ,     legacy_format=a_	)
            _a							=	tokenizer_p.save_pretrained(a_	)

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

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

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

            shutil.rmtree(a_	)

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

            _a							=	tokenizer_r.save_pretrained(a_     ,     legacy_format=a_	)
            _a							=	tokenizer_p.save_pretrained(a_	)

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

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

            shutil.rmtree(a_	)







@require_torch
@require_sentencepiece
@require_tokenizers
class    lowercase_    (unittest.TestCase     ):
      A__	:		Tuple       			=				'''facebook/mbart-large-50-one-to-many-mmt'''
      A__	:		str       			=				[
          ''' 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.''',
      ]
      A__	:		List[str]       			=				[
          '''Ş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.''',
      ]
      A__	:		Optional[int]       			=				[EN_CODE, 8274, 127873, 25916, 7, 8622, 2071, 438, 67485, 53, 187895, 23, 51712, 2]






      @classmethod
      def 			lowerCamelCase__    (    cls	)	->Union[str, Any]:







        '''simple docstring'''


        _a							=	MBartaaTokenizer.from_pretrained(
            cls.checkpoint_name     ,     src_lang="en_XX"     ,     tgt_lang="ro_RO"	)
        _a							=	1
        return cls






      def 			lowerCamelCase__    (    self	)	->List[Any]:







        '''simple docstring'''


        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	)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["mr_IN"]     ,     2_5_0_0_3_8	)






      def 			lowerCamelCase__    (    self	)	->Tuple:







        '''simple docstring'''


        _a							=	self.tokenizer.batch_encode_plus(self.src_text	).input_ids[0]
        self.assertListEqual(self.expected_src_tokens     ,     a_	)






      def 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        self.assertIn(a_     ,     self.tokenizer.all_special_ids	)
        _a							=	[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]
        _a							=	self.tokenizer.decode(a_     ,     skip_special_tokens=a_	)
        _a							=	self.tokenizer.decode(generated_ids[1:]     ,     skip_special_tokens=a_	)
        self.assertEqual(a_     ,     a_	)
        self.assertNotIn(self.tokenizer.eos_token     ,     a_	)






      def 			lowerCamelCase__    (    self	)	->List[str]:







        '''simple docstring'''


        _a							=	["this is gunna be a long sentence " * 2_0]
        assert isinstance(src_text[0]     ,     a_	)
        _a							=	1_0
        _a							=	self.tokenizer(a_     ,     max_length=a_     ,     truncation=a_	).input_ids[0]
        self.assertEqual(ids[0]     ,     a_	)
        self.assertEqual(ids[-1]     ,     2	)
        self.assertEqual(len(a_	)     ,     a_	)






      def 			lowerCamelCase__    (    self	)	->Optional[Any]:







        '''simple docstring'''


        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]	)     ,     [2_5_0_0_5_3, 2_5_0_0_0_1]	)






      def 			lowerCamelCase__    (    self	)	->Union[str, Any]:







        '''simple docstring'''


        _a							=	tempfile.mkdtemp()
        _a							=	self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(a_	)
        _a							=	MBartaaTokenizer.from_pretrained(a_	)
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids     ,     a_	)






      @require_torch
      def 			lowerCamelCase__    (    self	)	->int:







        '''simple docstring'''


        _a							=	self.tokenizer(self.src_text     ,     text_target=self.tgt_text     ,     padding=a_     ,     return_tensors="pt"	)
        _a							=	shift_tokens_right(batch["labels"]     ,     self.tokenizer.pad_token_id	)

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






      @require_torch
      def 			lowerCamelCase__    (    self	)	->Tuple:







        '''simple docstring'''


        _a							=	self.tokenizer(
            self.src_text     ,     text_target=self.tgt_text     ,     padding=a_     ,     truncation=a_     ,     max_length=len(self.expected_src_tokens	)     ,     return_tensors="pt"     ,     )
        _a							=	shift_tokens_right(batch["labels"]     ,     self.tokenizer.pad_token_id	)

        self.assertIsInstance(a_     ,     a_	)

        self.assertEqual((2, 1_4)     ,     batch.input_ids.shape	)
        self.assertEqual((2, 1_4)     ,     batch.attention_mask.shape	)
        _a							=	batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens     ,     a_	)
        self.assertEqual(2     ,     batch.decoder_input_ids[0, 0]	)  # decoder_start_token_id
        # 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 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        _a							=	self.tokenizer(self.src_text     ,     padding=a_     ,     truncation=a_     ,     max_length=3     ,     return_tensors="pt"	)
        _a							=	self.tokenizer(
            text_target=self.tgt_text     ,     padding=a_     ,     truncation=a_     ,     max_length=1_0     ,     return_tensors="pt"	)
        _a							=	targets["input_ids"]
        _a							=	shift_tokens_right(a_     ,     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 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        _a							=	self.tokenizer._build_translation_inputs(
            "A test"     ,     return_tensors="pt"     ,     src_lang="en_XX"     ,     tgt_lang="ar_AR"	)

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










"""simple docstring"""




import math






def        lowerCAmelCase (      UpperCamelCase_:							int					)       ->							list:







  '''simple docstring'''







  _a							=	[True] * n
  _a							=	False
  _a							=	False
  _a							=	True

  for i in range(3     , int(n**0.5 + 1					)     , 2					):
    _a							=	i * 2
    while index < n:
      _a							=	False
      _a							=	index + i

  _a							=	[2]

  for i in range(3     , UpperCamelCase_     , 2					):
    if is_prime[i]:
      primes.append(UpperCamelCase_					)

  return primes






def        lowerCAmelCase (      UpperCamelCase_:							int = 999966663333					)       ->							int:







  '''simple docstring'''







  _a							=	math.floor(math.sqrt(UpperCamelCase_					)					) + 100
  _a							=	prime_sieve(UpperCamelCase_					)

  _a							=	0
  _a							=	0
  _a							=	primes[prime_index]

  while (last_prime**2) <= limit:
    _a							=	primes[prime_index + 1]

    _a							=	last_prime**2
    _a							=	next_prime**2

    # Get numbers divisible by lps(current)
    _a							=	lower_bound + last_prime
    while upper_bound > current <= limit:
      matches_sum += current
      current += last_prime

    # Reset the upper_bound
    while (upper_bound - next_prime) > limit:
      upper_bound -= next_prime

    # Add the numbers divisible by ups(current)
    _a							=	upper_bound - next_prime
    while current > lower_bound:
      matches_sum += current
      current -= next_prime

    # Remove the numbers divisible by both ups and lps
    _a							=	0
    while upper_bound > current <= limit:
      if current <= lower_bound:
        # Increment the current number
        current += last_prime * next_prime
        continue

      if current > limit:
        break

      # Remove twice since it was added by both ups and lps
      matches_sum -= current * 2

      # Increment the current number
      current += last_prime * next_prime

    # Setup for next pair
    _a							=	next_prime
    prime_index += 1

  return matches_sum


if __name__ == "__main__":
     print(solution())


