




'''simple docstring'''


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_ 		=      get_tests_dir("fixtures/test_sentencepiece.model")


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

UpperCAmelCase_ 		=      25_60_47
UpperCAmelCase_ 		=      25_61_45





@require_sentencepiece
@require_tokenizers
class    __lowercase						(  __magic_name__       ,							unittest.TestCase ):
   _a							=      NllbTokenizer
   _a							=      NllbTokenizerFast
   _a							=      True
   _a							=      True
   _a							=      {}







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

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







   def 		UpperCamelCase__			(	self      )				->    Union[str, Any]:
     __a			=					NllbTokenizer(UpperCamelCase      ,							keep_accents=UpperCamelCase      )

     __a			=					tokenizer.tokenize('This is a test'      )
     self.assertListEqual(UpperCamelCase      ,							['▁This', '▁is', '▁a', '▁t', 'est']      )

     self.assertListEqual(
         tokenizer.convert_tokens_to_ids(UpperCamelCase      )      ,							[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(
         UpperCamelCase      ,							[
             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(UpperCamelCase      )
     self.assertListEqual(
         UpperCamelCase      ,							[
             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(UpperCamelCase      )
     self.assertListEqual(
         UpperCamelCase      ,							[
             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:
     __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(UpperCamelCase      ,							**UpperCamelCase      )
         __a			=					self.tokenizer_class.from_pretrained(UpperCamelCase      ,							**UpperCamelCase      )

         __a			=					tempfile.mkdtemp()

         __a			=					tokenizer_r.save_pretrained(UpperCamelCase      )
         __a			=					tokenizer_p.save_pretrained(UpperCamelCase      )

         # 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(UpperCamelCase      ,							UpperCamelCase      )

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

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

         shutil.rmtree(UpperCamelCase      )

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

         __a			=					tokenizer_r.save_pretrained(UpperCamelCase      ,							legacy_format=UpperCamelCase      )
         __a			=					tokenizer_p.save_pretrained(UpperCamelCase      )

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

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

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

         shutil.rmtree(UpperCamelCase      )

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

         __a			=					tokenizer_r.save_pretrained(UpperCamelCase      ,							legacy_format=UpperCamelCase      )
         __a			=					tokenizer_p.save_pretrained(UpperCamelCase      )

         # 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(UpperCamelCase      )
         __a			=					tokenizer_p.from_pretrained(UpperCamelCase      )

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

         shutil.rmtree(UpperCamelCase      )







   @require_torch
   def 		UpperCamelCase__			(	self      )				->    Optional[Any]:
     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=UpperCamelCase      ,							tgt_texts=UpperCamelCase      ,							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(
             UpperCamelCase      ,							tgt_texts=UpperCamelCase      ,							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=UpperCamelCase      ,							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'      ,							UpperCamelCase      )







   @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'      )
   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     pass







   def 		UpperCamelCase__			(	self      )				->    List[str]:
     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
       with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"      ):
         __a			=					[AddedToken('<special>'      ,							lstrip=UpperCamelCase      )]

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

         __a			=					tokenizer_r.encode('<special>'      ,							add_special_tokens=UpperCamelCase      )[0]

         self.assertTrue(special_token_id in r_output      )

         if self.test_slow_tokenizer:
           __a			=					self.rust_tokenizer_class.from_pretrained(
               UpperCamelCase      ,							additional_special_tokens=UpperCamelCase      ,							**UpperCamelCase      ,							)
           __a			=					self.tokenizer_class.from_pretrained(
               UpperCamelCase      ,							additional_special_tokens=UpperCamelCase      ,							**UpperCamelCase      )

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

           __a			=					tokenizer_cr.encode('Hey this is a <special> token'      )

           self.assertEqual(UpperCamelCase      ,							UpperCamelCase      )
           self.assertEqual(UpperCamelCase      ,							UpperCamelCase      )
           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 ):
   _a							=      """facebook/nllb-200-distilled-600M"""
   _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.""",
   ]
   _a							=      [
       256047,
       16297,
       134408,
       8165,
       248066,
       14734,
       950,
       1135,
       105721,
       3573,
       83,
       27352,
       108,
       49486,
       2,
   ]







   @classmethod
   def 		UpperCamelCase__			(	cls      )				->    str:
     __a			=					NllbTokenizer.from_pretrained(
         cls.checkpoint_name      ,							src_lang='eng_Latn'      ,							tgt_lang='ron_Latn'      )
     __a			=					1
     return cls







   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     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      )				->    int:
     __a			=					self.tokenizer.batch_encode_plus(self.src_text      ).input_ids[0]
     self.assertListEqual(self.expected_src_tokens      ,							UpperCamelCase      )







   def 		UpperCamelCase__			(	self      )				->    Union[str, Any]:
     self.assertIn(UpperCamelCase      ,							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(UpperCamelCase      ,							skip_special_tokens=UpperCamelCase      )
     __a			=					self.tokenizer.decode(generated_ids[1:]      ,							skip_special_tokens=UpperCamelCase      )
     self.assertEqual(UpperCamelCase      ,							UpperCamelCase      )
     self.assertNotIn(self.tokenizer.eos_token      ,							UpperCamelCase      )







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







   def 		UpperCamelCase__			(	self      )				->    Optional[Any]:
     self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']      )      ,							[25_6203, 3]      )







   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     __a			=					tempfile.mkdtemp()
     __a			=					self.tokenizer.fairseq_tokens_to_ids
     self.tokenizer.save_pretrained(UpperCamelCase      )
     __a			=					NllbTokenizer.from_pretrained(UpperCamelCase      )
     self.assertDictEqual(new_tok.fairseq_tokens_to_ids      ,							UpperCamelCase      )







   @require_torch
   def 		UpperCamelCase__			(	self      )				->    Any:
     __a			=					self.tokenizer(
         self.src_text      ,							text_target=self.tgt_text      ,							padding=UpperCamelCase      ,							truncation=UpperCamelCase      ,							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(UpperCamelCase      ,							UpperCamelCase      )

     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      ,							UpperCamelCase      )
     self.assertEqual(UpperCamelCase      ,							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:
     __a			=					self.tokenizer(self.src_text      ,							padding=UpperCamelCase      ,							truncation=UpperCamelCase      ,							max_length=3      ,							return_tensors='pt'      )
     __a			=					self.tokenizer(
         text_target=self.tgt_text      ,							padding=UpperCamelCase      ,							truncation=UpperCamelCase      ,							max_length=10      ,							return_tensors='pt'      )
     __a			=					targets['input_ids']
     __a			=					shift_tokens_right(
         UpperCamelCase      ,							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      )				->    Tuple:
     __a			=					self.tokenizer._build_translation_inputs(
         'A test'      ,							return_tensors='pt'      ,							src_lang='eng_Latn'      ,							tgt_lang='fra_Latn'      )

     self.assertEqual(
         nested_simplify(UpperCamelCase      )      ,							{
             # 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      )				->    Any:
     __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]      )









'''simple docstring'''


import os


def 						SCREAMING_SNAKE_CASE       (      ):
  with open(os.path.dirname(a_			) + '/grid.txt'			) as f:
    __a			=					[]  # noqa: E741
    for _ in range(20			):
      l.append([int(a_			) for x in f.readline().split()]			)

    __a			=					0

    # right
    for i in range(20			):
      for j in range(17			):
        __a			=					l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
        if temp > maximum:
          __a			=					temp

        # down
    for i in range(17			):
      for j in range(20			):
        __a			=					l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
        if temp > maximum:
          __a			=					temp

        # diagonal 1
    for i in range(17			):
      for j in range(17			):
        __a			=					l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
        if temp > maximum:
          __a			=					temp

        # diagonal 2
    for i in range(17			):
      for j in range(3				,					20			):
        __a			=					l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
        if temp > maximum:
          __a			=					temp
    return maximum


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



