


"""simple docstring"""


import os
import re
import warnings
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
    from .tokenization_ta import TaTokenizer
else:
    __lowerCamelCase      :List[str]	    =		None


__lowerCamelCase      :Tuple	    =		logging.get_logger(__name__)

__lowerCamelCase      :List[str]	    =		{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

__lowerCamelCase      :List[str]	    =		{
    'vocab_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/spiece.model',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/spiece.model',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/spiece.model',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/spiece.model',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/spiece.model',
    },
    'tokenizer_file': {
        't5-small': 'https://huggingface.co/t5-small/resolve/main/tokenizer.json',
        't5-base': 'https://huggingface.co/t5-base/resolve/main/tokenizer.json',
        't5-large': 'https://huggingface.co/t5-large/resolve/main/tokenizer.json',
        't5-3b': 'https://huggingface.co/t5-3b/resolve/main/tokenizer.json',
        't5-11b': 'https://huggingface.co/t5-11b/resolve/main/tokenizer.json',
    },
}


# TODO(PVP) - this should be removed in Transformers v5
__lowerCamelCase      :Any	    =		{
    't5-small': 512,
    't5-base': 512,
    't5-large': 512,
    't5-3b': 512,
    't5-11b': 512,
}


class 			A__	(						__A):


     """simple docstring"""
     snake_case__	:					Optional[Any]													=VOCAB_FILES_NAMES
     snake_case__	:					Optional[int]													=PRETRAINED_VOCAB_FILES_MAP
     snake_case__	:					Any													=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     snake_case__	:					List[str]													=['''input_ids''', '''attention_mask''']
     snake_case__	:					str													=TaTokenizer

     snake_case__	:					Tuple													=[]

     def __init__(	self:						Tuple     ,		__a:						str=None     ,		__a:						Union[str, Any]=None     ,		__a:						Optional[int]="</s>"     ,		__a:						Dict="<unk>"     ,		__a:						Dict="<pad>"     ,		__a:						Union[str, Any]=100     ,		__a:						List[str]=None     ,		**__a:						int     ,		)->    Any:





           if extra_ids > 0 and additional_special_tokens is None:
                 lowerCamelCase					:					Tuple        =	[f'<extra_id_{i}>' for i in range(__a	)]
           elif extra_ids > 0 and additional_special_tokens is not None:
                 # Check that we have the right number of extra special tokens
                 lowerCamelCase					:					Dict        =	len(set(filter(lambda __a	: bool("""extra_id_""" in str(__a	)	)     ,		__a	)	)	)
                 if extra_tokens != extra_ids:
                       raise ValueError(
                           f'Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are'
                           """ provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids"""
                           """ tokens"""	)

           super().__init__(
               __a     ,		tokenizer_file=__a     ,		eos_token=__a     ,		unk_token=__a     ,		pad_token=__a     ,		extra_ids=__a     ,		additional_special_tokens=__a     ,		**__a     ,		)

           lowerCamelCase					:					List[str]        =	vocab_file
           lowerCamelCase					:					List[Any]        =	False if not self.vocab_file else True
           lowerCamelCase					:					Optional[int]        =	extra_ids

     @staticmethod
     def 		a__						(	__a:						str     ,		__a:						Tuple     ,		__a:						Dict	)->    Union[str, Any]:





           if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
                 lowerCamelCase					:					Optional[Any]        =	TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
                 if init_max_model_length is not None and init_max_model_length != max_model_length:
                       return init_max_model_length
                 elif init_max_model_length is None:
                       warnings.warn(
                           """This tokenizer was incorrectly instantiated with a model max length of"""
                           f' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this'
                           """ behavior is kept to avoid breaking backwards compatibility when padding/encoding with"""
                           """ `truncation is True`.\n- Be aware that you SHOULD NOT rely on"""
                           f' {pretrained_model_name_or_path} automatically truncating your input to'
                           f' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences'
                           f' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with'
                           """ `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please"""
                           """ instantiate this tokenizer with `model_max_length` set to your preferred value."""     ,		__a     ,		)

           return max_model_length

     def 		a__						(	self:						Optional[Any]     ,		__a:						List[str]     ,		__a:						Union[str, Any] = None	)->    List[str]:





           if not self.can_save_slow_tokenizer:
                 raise ValueError(
                     """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
                     """tokenizer."""	)

           if not os.path.isdir(__a	):
                 logger.error(f'Vocabulary path ({save_directory}) should be a directory'	)
                 return
           lowerCamelCase					:					Union[str, Any]        =	os.path.join(
               __a     ,		(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]	)

           if os.path.abspath(self.vocab_file	) != os.path.abspath(__a	):
                 copyfile(self.vocab_file     ,		__a	)
                 logger.info(f'Copy vocab file to {out_vocab_file}'	)

           return (out_vocab_file,)

     def 		a__						(	self:						int     ,		__a:						Optional[int]     ,		__a:						Optional[int] = None	)->    Dict:
           lowerCamelCase					:					int        =	token_ids_a + [self.eos_token_id]
           if token_ids_a is None:
                 return self.prefix_tokens + token_ids_a
           else:
                 lowerCamelCase					:					Tuple        =	token_ids_a + [self.eos_token_id]
                 return self.prefix_tokens + token_ids_a + token_ids_a

     def 		a__						(	self:						Optional[Any]     ,		__a:						Optional[int]     ,		__a:						Dict = None	)->    List[Any]:
           lowerCamelCase					:					Dict        =	[self.eos_token_id]

           if token_ids_a is None:
                 return len(token_ids_a + eos	) * [0]
           return len(token_ids_a + eos + token_ids_a + eos	) * [0]

     def 		a__						(	self:						Optional[Any]	)->    List[Any]:
           return list(
               set(filter(lambda __a	: bool(re.search(r"""<extra_id_\d+>"""     ,		__a	)	) is not None     ,		self.additional_special_tokens	)	)	)







     def 		a__						(	self:						List[Any]	)->    str:
           return [self.convert_tokens_to_ids(__a	) for token in self.get_sentinel_tokens()]








"""simple docstring"""


import os




def   snake_case		(     )   ->      Optional[Any]:
      with open(os.path.dirname(UpperCamelCase__    ) + """/grid.txt"""    ) as f:
            lowerCamelCase					:					int        =	[]  # noqa: E741
            for _ in range(20    ):
                  l.append([int(UpperCamelCase__    ) for x in f.readline().split()]    )

            lowerCamelCase					:					Union[str, Any]        =	0

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

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

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

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


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




