




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


__UpperCamelCase   :			Optional[int]          = get_tests_dir("fixtures/test_sentencepiece.model")


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

__UpperCamelCase   :			Union[str, Any]          = 256_047
__UpperCamelCase   :			int          = 256_145

@require_sentencepiece
@require_tokenizers
class 						__lowerCAmelCase      (      __snake_case ,			unittest.TestCase					):
							UpperCamelCase__   	=    NllbTokenizer
							UpperCamelCase__   	=    NllbTokenizerFast
							UpperCamelCase__   	=    True
							UpperCamelCase__   	=    True
							UpperCamelCase__   	=    {}
							def  lowerCamelCase__				(		self		:Any							):







								'''simple docstring'''







								super().setUp()

								# We have a SentencePiece fixture for testing
								a									=				NllbTokenizer(__lowerCamelCase						, keep_accents=__lowerCamelCase							)
								tokenizer.save_pretrained(self.tmpdirname							)
							def  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								a									=				NllbTokenizer(__lowerCamelCase						, keep_accents=__lowerCamelCase							)

								a									=				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]]						, )

								a									=				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""",
								        """é""",
								        """.""",
								    ]						, )
								a									=				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]
								    ]						, )

								a									=				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  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								a									=				(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})'							):
										a									=				self.rust_tokenizer_class.from_pretrained(__lowerCamelCase						, **__lowerCamelCase							)
										a									=				self.tokenizer_class.from_pretrained(__lowerCamelCase						, **__lowerCamelCase							)

										a									=				tempfile.mkdtemp()

										a									=				tokenizer_r.save_pretrained(__lowerCamelCase							)
										a									=				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							)							)
										a									=				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
										a									=				tokenizer_r.from_pretrained(__lowerCamelCase							)
										a									=				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
										a									=				tempfile.mkdtemp()

										a									=				tokenizer_r.save_pretrained(__lowerCamelCase						, legacy_format=__lowerCamelCase							)
										a									=				tokenizer_p.save_pretrained(__lowerCamelCase							)

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

										# Checks everything loads correctly in the same way
										a									=				tokenizer_r.from_pretrained(__lowerCamelCase							)
										a									=				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
										a									=				tempfile.mkdtemp()

										a									=				tokenizer_r.save_pretrained(__lowerCamelCase						, legacy_format=__lowerCamelCase							)
										a									=				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
										a									=				tokenizer_r.from_pretrained(__lowerCamelCase							)
										a									=				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  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								if not self.test_seqaseq:
									return

								a									=				self.get_tokenizers()
								for tokenizer in tokenizers:
									with self.subTest(F'{tokenizer.__class__.__name__}'							):
										# Longer text that will definitely require truncation.
										a									=				[
										    """ 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									=				[
										    """Ş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:
											a									=				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
										a									=				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							)

										a									=				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  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								pass





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







								'''simple docstring'''







								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'							):
										a									=				[AddedToken("""<special>"""						, lstrip=__lowerCamelCase							)]

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

										a									=				tokenizer_r.encode("""<special>"""						, add_special_tokens=__lowerCamelCase							)[0]

										self.assertTrue(special_token_id in r_output							)

										if self.test_slow_tokenizer:
											a									=				self.rust_tokenizer_class.from_pretrained(
											    __lowerCamelCase						, additional_special_tokens=__lowerCamelCase						, **__lowerCamelCase						, )
											a									=				self.tokenizer_class.from_pretrained(
											    __lowerCamelCase						, additional_special_tokens=__lowerCamelCase						, **__lowerCamelCase							)

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

											a									=				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 						__lowerCAmelCase      (      unittest.TestCase					):
							UpperCamelCase__   	=    '''facebook/nllb-200-distilled-600M'''
							UpperCamelCase__   	=    [
							    ''' 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.''',
							]
							UpperCamelCase__   	=    [
							    '''Ş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.''',
							]
							UpperCamelCase__   	=    [
							    256047,
							    16297,
							    134408,
							    8165,
							    248066,
							    14734,
							    950,
							    1135,
							    105721,
							    3573,
							    83,
							    27352,
							    108,
							    49486,
							    2,
							]
							@classmethod
							def  lowerCamelCase__				(		cls		:int							):







								'''simple docstring'''







								a									=				NllbTokenizer.from_pretrained(
								    cls.checkpoint_name						, src_lang="""eng_Latn"""						, tgt_lang="""ron_Latn"""							)
								a									=				1
								return cls
							def  lowerCamelCase__				(		self		:Dict							):







								'''simple docstring'''







								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  lowerCamelCase__				(		self		:Union[str, Any]							):







								'''simple docstring'''







								a									=				self.tokenizer.batch_encode_plus(self.src_text							).input_ids[0]
								self.assertListEqual(self.expected_src_tokens						, __lowerCamelCase							)
							def  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								self.assertIn(__lowerCamelCase						, self.tokenizer.all_special_ids							)
								# fmt: off
								a									=				[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

								a									=				self.tokenizer.decode(__lowerCamelCase						, skip_special_tokens=__lowerCamelCase							)
								a									=				self.tokenizer.decode(generated_ids[1:]						, skip_special_tokens=__lowerCamelCase							)
								self.assertEqual(__lowerCamelCase						, __lowerCamelCase							)
								self.assertNotIn(self.tokenizer.eos_token						, __lowerCamelCase							)
							def  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







								a									=				["""this is gunna be a long sentence """ * 20]
								assert isinstance(src_text[0]						, __lowerCamelCase							)
								a									=				10
								a									=				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  lowerCamelCase__				(		self		:List[str]							):







								'''simple docstring'''







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







								'''simple docstring'''







								a									=				tempfile.mkdtemp()
								a									=				self.tokenizer.fairseq_tokens_to_ids
								self.tokenizer.save_pretrained(__lowerCamelCase							)
								a									=				NllbTokenizer.from_pretrained(__lowerCamelCase							)
								self.assertDictEqual(new_tok.fairseq_tokens_to_ids						, __lowerCamelCase							)
							@require_torch
							def  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								a									=				self.tokenizer(
								    self.src_text						, text_target=self.tgt_text						, padding=__lowerCamelCase						, truncation=__lowerCamelCase						, max_length=len(self.expected_src_tokens							)						, return_tensors="""pt"""						, )
								a									=				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							)
								a									=				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  lowerCamelCase__				(		self		:str							):







								'''simple docstring'''







								a									=				self.tokenizer(self.src_text						, padding=__lowerCamelCase						, truncation=__lowerCamelCase						, max_length=3						, return_tensors="""pt"""							)
								a									=				self.tokenizer(
								    text_target=self.tgt_text						, padding=__lowerCamelCase						, truncation=__lowerCamelCase						, max_length=10						, return_tensors="""pt"""							)
								a									=				targets["""input_ids"""]
								a									=				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  lowerCamelCase__				(		self		:Any							):







								'''simple docstring'''







								a									=				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  lowerCamelCase__				(		self		:Optional[int]							):







								'''simple docstring'''







								a									=				True
								a									=				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]							)

								a									=				False
								a									=				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]							)





def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   if n == 1 or not isinstance(lowerCAmelCase_	,    lowerCAmelCase_ ):
      return 0
   elif n == 2:
      return 1
   else:
      UpperCAmelCase      					=  [0, 1]
      for i in range(2	,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  0
   UpperCAmelCase      					=  2

   while digits < n:
      index += 1
      UpperCAmelCase      					=  len(str(fibonacci(lowerCAmelCase_ ) ) )

   return index
def 	_UpperCamelCase					(    lowerCAmelCase_ = 1_0_0_0 )    ->int:
   return fibonacci_digits_index(lowerCAmelCase_ )


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



