




'''simple docstring'''

import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_mobilebert import MobileBertTokenizer


a  :				Any									=  logging.get_logger(__name__)

a  :				List[str]									=  {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

a  :				Dict									=  {
    'vocab_file': {'mobilebert-uncased': 'https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt'},
    'tokenizer_file': {
        'mobilebert-uncased': 'https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json'
    },
}

a  :				Tuple									=  {'mobilebert-uncased': 512}


a  :				Optional[int]									=  {}






class 						a				(   _lowerCamelCase     ):
				snake_case_      =		VOCAB_FILES_NAMES
				snake_case_      =		PRETRAINED_VOCAB_FILES_MAP
				snake_case_      =		PRETRAINED_INIT_CONFIGURATION
				snake_case_      =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				snake_case_      =		MobileBertTokenizer


				def __init__(		self    :					int       ,				lowercase_    :					Tuple=None       ,				lowercase_    :					int=None       ,				lowercase_    :					int=True       ,				lowercase_    :					int="[UNK]"       ,				lowercase_    :					Union[str, Any]="[SEP]"       ,				lowercase_    :					str="[PAD]"       ,				lowercase_    :					List[str]="[CLS]"       ,				lowercase_    :					List[str]="[MASK]"       ,				lowercase_    :					Union[str, Any]=True       ,				lowercase_    :					List[str]=None       ,				**lowercase_    :					int       ,				):
									super().__init__(
									    lowercase_       ,				tokenizer_file=lowercase_       ,				do_lower_case=lowercase_       ,				unk_token=lowercase_       ,				sep_token=lowercase_       ,				pad_token=lowercase_       ,				cls_token=lowercase_       ,				mask_token=lowercase_       ,				tokenize_chinese_chars=lowercase_       ,				strip_accents=lowercase_       ,				**lowercase_       ,				)

									snake_case_									=				json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
									if (
									    normalizer_state.get('''lowercase'''       ,				lowercase_					) != do_lower_case
									    or normalizer_state.get('''strip_accents'''       ,				lowercase_					) != strip_accents
									    or normalizer_state.get('''handle_chinese_chars'''       ,				lowercase_					) != tokenize_chinese_chars
									):
														snake_case_									=				getattr(lowercase_       ,				normalizer_state.pop('''type'''					)					)
														snake_case_									=				do_lower_case
														snake_case_									=				strip_accents
														snake_case_									=				tokenize_chinese_chars
														snake_case_									=				normalizer_class(**lowercase_					)

									snake_case_									=				do_lower_case


				def   A_ (		self    :					str       ,				lowercase_    :					List[str]       ,				lowercase_    :					Optional[int]=None					):
									snake_case_									=				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

									if token_ids_a:
														output += token_ids_a + [self.sep_token_id]

									return output


				def   A_ (		self    :					List[str]       ,				lowercase_    :					List[int]       ,				lowercase_    :					Optional[List[int]] = None					):
									snake_case_									=				[self.sep_token_id]
									snake_case_									=				[self.cls_token_id]
									if token_ids_a is None:
														return len(cls + token_ids_a + sep					) * [0]
									return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]


				def   A_ (		self    :					Union[str, Any]       ,				lowercase_    :					str       ,				lowercase_    :					Optional[str] = None					):
									snake_case_									=				self._tokenizer.model.save(lowercase_       ,				name=lowercase_					)
									return tuple(lowercase_					)









"""simple docstring"""
import os

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

						UpperCAmelCase_     : Any			     =					0

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

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

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

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


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



