





'''simple docstring'''




import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
  __SCREAMING_SNAKE_CASE     :int       =				'''pt'''
elif is_tf_available():
  __SCREAMING_SNAKE_CASE     :Union[str, Any]       =				'''tf'''
else:
  __SCREAMING_SNAKE_CASE     :Any       =				'''jax'''







class   A_	(  __snake_case							,						unittest.TestCase			):
 _lowerCamelCase  : Tuple           =							PerceiverTokenizer
 _lowerCamelCase  : List[str]           =							False




 def      lowercase	(					self       :    Optional[int]    ):
      super().setUp()
      _UpperCAmelCase     							=   PerceiverTokenizer()
      tokenizer.save_pretrained(self.tmpdirname    )




 @cached_property
 def      lowercase	(					self       :    Optional[Any]    ):
      return PerceiverTokenizer.from_pretrained("deepmind/language-perceiver"    )




 def      lowercase	(					self       :    List[Any]	,			**snake_case_       :    Any    ):
      return self.tokenizer_class.from_pretrained(self.tmpdirname	,			**__SCREAMING_SNAKE_CASE    )




 def      lowercase	(					self       :    Optional[Any]	,			snake_case_       :    Optional[Any]	,			snake_case_       :    str=False	,			snake_case_       :    List[Any]=2_0	,			snake_case_       :    str=5    ):
      # XXX The default common tokenizer tests assume that every ID is decodable on its own.
      # This assumption is invalid for Perceiver because single bytes might not be
      # valid utf-8 (byte 128 for instance).
      # Here we're overriding the smallest possible method to provide
      # a clean sequence without making the same assumption.

      _UpperCAmelCase     							=   []
      for i in range(len(__SCREAMING_SNAKE_CASE    )    ):
           try:
                _UpperCAmelCase     							=   tokenizer.decode([i]	,			clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE    )
           except UnicodeDecodeError:
                pass
           toks.append((i, tok)    )

      _UpperCAmelCase     							=   list(filter(lambda snake_case_    : re.match(r"^[ a-zA-Z]+$"	,			t[1]    )	,			__SCREAMING_SNAKE_CASE    )    )
      _UpperCAmelCase     							=   list(filter(lambda snake_case_    : [t[0]] == tokenizer.encode(t[1]	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )	,			__SCREAMING_SNAKE_CASE    )    )
      if max_length is not None and len(__SCREAMING_SNAKE_CASE    ) > max_length:
           _UpperCAmelCase     							=   toks[:max_length]
      if min_length is not None and len(__SCREAMING_SNAKE_CASE    ) < min_length and len(__SCREAMING_SNAKE_CASE    ) > 0:
           while len(__SCREAMING_SNAKE_CASE    ) < min_length:
                _UpperCAmelCase     							=   toks + toks
           # toks_str = [t[1] for t in toks]
      _UpperCAmelCase     							=   [t[0] for t in toks]

      # Ensure consistency
      _UpperCAmelCase     							=   tokenizer.decode(__SCREAMING_SNAKE_CASE	,			clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE    )
      if " " not in output_txt and len(__SCREAMING_SNAKE_CASE    ) > 1:
           _UpperCAmelCase     							=   (
               tokenizer.decode([toks_ids[0]]	,			clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE    )
               + " "
               + tokenizer.decode(toks_ids[1:]	,			clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE    )
           )
      if with_prefix_space:
           _UpperCAmelCase     							=   " " + output_txt
      _UpperCAmelCase     							=   tokenizer.encode(__SCREAMING_SNAKE_CASE	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )
      return output_txt, output_ids




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   self.perceiver_tokenizer
      _UpperCAmelCase     							=   "Unicode €."
      _UpperCAmelCase     							=   tokenizer(__SCREAMING_SNAKE_CASE    )
      _UpperCAmelCase     							=   [4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
      self.assertEqual(encoded["input_ids"]	,			__SCREAMING_SNAKE_CASE    )

      # decoding
      _UpperCAmelCase     							=   tokenizer.decode(__SCREAMING_SNAKE_CASE    )
      self.assertEqual(__SCREAMING_SNAKE_CASE	,			"[CLS]Unicode €.[SEP]"    )

      _UpperCAmelCase     							=   tokenizer("e è é ê ë"    )
      _UpperCAmelCase     							=   [4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
      self.assertEqual(encoded["input_ids"]	,			__SCREAMING_SNAKE_CASE    )
      # decoding
      _UpperCAmelCase     							=   tokenizer.decode(__SCREAMING_SNAKE_CASE    )
      self.assertEqual(__SCREAMING_SNAKE_CASE	,			"[CLS]e è é ê ë[SEP]"    )

      # encode/decode, but with `encode` instead of `__call__`
      self.assertEqual(tokenizer.decode(tokenizer.encode("e è é ê ë"    )    )	,			"[CLS]e è é ê ë[SEP]"    )




 def      lowercase	(					self       :    List[Any]    ):
      _UpperCAmelCase     							=   self.perceiver_tokenizer
      _UpperCAmelCase     							=   ["A long paragraph for summarization.", "Another paragraph for summarization."]
      # fmt: off
      _UpperCAmelCase     							=   [4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
      # fmt: on
      _UpperCAmelCase     							=   tokenizer(__SCREAMING_SNAKE_CASE	,			padding=__SCREAMING_SNAKE_CASE	,			return_tensors=__SCREAMING_SNAKE_CASE    )
      self.assertIsInstance(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )

      if FRAMEWORK != "jax":
           _UpperCAmelCase     							=   list(batch.input_ids.numpy()[0]    )
      else:
           _UpperCAmelCase     							=   list(batch.input_ids.tolist()[0]    )

      self.assertListEqual(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )

      self.assertEqual((2, 3_8)	,			batch.input_ids.shape    )
      self.assertEqual((2, 3_8)	,			batch.attention_mask.shape    )




 def      lowercase	(					self       :    str    ):
      _UpperCAmelCase     							=   self.perceiver_tokenizer
      _UpperCAmelCase     							=   ["A long paragraph for summarization.", "Another paragraph for summarization."]
      _UpperCAmelCase     							=   tokenizer(__SCREAMING_SNAKE_CASE	,			padding=__SCREAMING_SNAKE_CASE	,			return_tensors=__SCREAMING_SNAKE_CASE    )
      # check if input_ids are returned and no decoder_input_ids
      self.assertIn("input_ids"	,			__SCREAMING_SNAKE_CASE    )
      self.assertIn("attention_mask"	,			__SCREAMING_SNAKE_CASE    )
      self.assertNotIn("decoder_input_ids"	,			__SCREAMING_SNAKE_CASE    )
      self.assertNotIn("decoder_attention_mask"	,			__SCREAMING_SNAKE_CASE    )




 def      lowercase	(					self       :    Any    ):
      _UpperCAmelCase     							=   self.perceiver_tokenizer
      _UpperCAmelCase     							=   [
          "Summary of the text.",
          "Another summary.",
      ]
      _UpperCAmelCase     							=   tokenizer(
          text_target=__SCREAMING_SNAKE_CASE	,			max_length=3_2	,			padding="max_length"	,			truncation=__SCREAMING_SNAKE_CASE	,			return_tensors=__SCREAMING_SNAKE_CASE    )
      self.assertEqual(3_2	,			targets["input_ids"].shape[1]    )




 def      lowercase	(					self       :    int    ):
      # safety check on max_len default value so we are sure the test works
      _UpperCAmelCase     							=   self.get_tokenizers()
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                self.assertNotEqual(tokenizer.model_max_length	,			4_2    )

           # Now let's start the test
      _UpperCAmelCase     							=   self.get_tokenizers()
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                # Isolate this from the other tests because we save additional tokens/etc
                _UpperCAmelCase     							=   tempfile.mkdtemp()

                _UpperCAmelCase     							=   " He is very happy, UNwant\u00E9d,running"
                _UpperCAmelCase     							=   tokenizer.encode(__SCREAMING_SNAKE_CASE	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )
                tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(__SCREAMING_SNAKE_CASE    )
                _UpperCAmelCase     							=   after_tokenizer.encode(__SCREAMING_SNAKE_CASE	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )
                self.assertListEqual(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )

                shutil.rmtree(__SCREAMING_SNAKE_CASE    )

      _UpperCAmelCase     							=   self.get_tokenizers(model_max_length=4_2    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                # Isolate this from the other tests because we save additional tokens/etc
                _UpperCAmelCase     							=   tempfile.mkdtemp()

                _UpperCAmelCase     							=   " He is very happy, UNwant\u00E9d,running"
                tokenizer.add_tokens(["bim", "bambam"]    )
                _UpperCAmelCase     							=   tokenizer.additional_special_tokens
                additional_special_tokens.append("new_additional_special_token"    )
                tokenizer.add_special_tokens({"additional_special_tokens": additional_special_tokens}    )
                _UpperCAmelCase     							=   tokenizer.encode(__SCREAMING_SNAKE_CASE	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )
                tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(__SCREAMING_SNAKE_CASE    )
                _UpperCAmelCase     							=   after_tokenizer.encode(__SCREAMING_SNAKE_CASE	,			add_special_tokens=__SCREAMING_SNAKE_CASE    )
                self.assertListEqual(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )
                self.assertIn("new_additional_special_token"	,			after_tokenizer.additional_special_tokens    )
                self.assertEqual(after_tokenizer.model_max_length	,			4_2    )

                _UpperCAmelCase     							=   tokenizer.__class__.from_pretrained(__SCREAMING_SNAKE_CASE	,			model_max_length=4_3    )
                self.assertEqual(tokenizer.model_max_length	,			4_3    )

                shutil.rmtree(__SCREAMING_SNAKE_CASE    )




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   []
      if self.test_slow_tokenizer:
           tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())    )

      if self.test_rust_tokenizer:
           tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())    )

      for tokenizer_class, tokenizer_utils in tokenizer_list:
           with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer_utils.save_pretrained(__SCREAMING_SNAKE_CASE    )

                with open(os.path.join(__SCREAMING_SNAKE_CASE	,			"special_tokens_map.json"    )	,			encoding="utf-8"    ) as json_file:
                     _UpperCAmelCase     							=   json.load(__SCREAMING_SNAKE_CASE    )

                with open(os.path.join(__SCREAMING_SNAKE_CASE	,			"tokenizer_config.json"    )	,			encoding="utf-8"    ) as json_file:
                     _UpperCAmelCase     							=   json.load(__SCREAMING_SNAKE_CASE    )

                _UpperCAmelCase     							=   [f'<extra_id_{i}>' for i in range(1_2_5    )]

                _UpperCAmelCase     							=   added_tokens_extra_ids + [
                    "an_additional_special_token"
                ]
                _UpperCAmelCase     							=   added_tokens_extra_ids + [
                    "an_additional_special_token"
                ]

                with open(os.path.join(__SCREAMING_SNAKE_CASE	,			"special_tokens_map.json"    )	,			"w"	,			encoding="utf-8"    ) as outfile:
                     json.dump(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )
                with open(os.path.join(__SCREAMING_SNAKE_CASE	,			"tokenizer_config.json"    )	,			"w"	,			encoding="utf-8"    ) as outfile:
                     json.dump(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )

                # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                # "special_tokens_map.json" files
                _UpperCAmelCase     							=   tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE	,			)
                self.assertIn(
                    "an_additional_special_token"	,			tokenizer_without_change_in_init.additional_special_tokens    )
                self.assertEqual(
                    ["an_additional_special_token"]	,			tokenizer_without_change_in_init.convert_ids_to_tokens(
                        tokenizer_without_change_in_init.convert_tokens_to_ids(["an_additional_special_token"]    )    )	,			)

                # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                _UpperCAmelCase     							=   added_tokens_extra_ids + [AddedToken("a_new_additional_special_token"	,			lstrip=__SCREAMING_SNAKE_CASE    )]
                _UpperCAmelCase     							=   tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE	,			additional_special_tokens=__SCREAMING_SNAKE_CASE	,			)

                self.assertIn("a_new_additional_special_token"	,			tokenizer.additional_special_tokens    )
                self.assertEqual(
                    ["a_new_additional_special_token"]	,			tokenizer.convert_ids_to_tokens(
                        tokenizer.convert_tokens_to_ids(["a_new_additional_special_token"]    )    )	,			)




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   self.perceiver_tokenizer
      self.assertEqual(tokenizer.decode([1_7_8]    )	,			"�"    )




 def      lowercase	(					self       :    str    ):
      pass




 def      lowercase	(					self       :    int    ):
      pass




 def      lowercase	(					self       :    List[str]    ):
      pass




 def      lowercase	(					self       :    List[str]    ):
      pass




 def      lowercase	(					self       :    str    ):
      # The default common tokenizer tests uses invalid tokens for Perceiver that can only accept one-character
      # strings and special added tokens as tokens
      _UpperCAmelCase     							=   self.get_tokenizers(fast=__SCREAMING_SNAKE_CASE	,			do_lower_case=__SCREAMING_SNAKE_CASE    )
      for tokenizer in tokenizers:
           with self.subTest(f'{tokenizer.__class__.__name__}'    ):
                _UpperCAmelCase     							=   ["[CLS]", "t", "h", "i", "s", " ", "i", "s", " ", "a", " ", "t", "e", "s", "t", "[SEP]"]
                _UpperCAmelCase     							=   tokenizer.convert_tokens_to_string(__SCREAMING_SNAKE_CASE    )

                self.assertIsInstance(__SCREAMING_SNAKE_CASE	,			__SCREAMING_SNAKE_CASE    )












"""simple docstring"""





import os







def      lowerCamelCase__       (							)      ->				List[Any]:
  with open(os.path.dirname(_lowerCamelCase ) + '/grid.txt' ) as f:
    lowerCamelCase_         =						[]  # noqa: E741
    for _ in range(20 ):
      l.append([int(_lowerCamelCase ) for x in f.readline().split()] )

    lowerCamelCase_         =						0

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

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

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

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


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




