






"""simple docstring"""
from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def 				snake_case      (   A__						):
			return ConvertCommand(
			    args.model_type	,args.tf_checkpoint	,args.pytorch_dump_output	,args.config	,args.finetuning_task_name						)


lowerCamelCase_					=      '''
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
'''







class 			UpperCamelCase_       (__A     ):





	@staticmethod
	def      _SCREAMING_SNAKE_CASE      (      lowerCAmelCase_					: ArgumentParser						)						->			List[Any]:
				UpperCAmelCase_     : Dict			     =					parser.add_parser(
				    "convert"	,	help="CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints."	,	)
				train_parser.add_argument("--model_type"	,	type=lowerCAmelCase_	,	required=lowerCAmelCase_	,	help="Model's type."						)
				train_parser.add_argument(
				    "--tf_checkpoint"	,	type=lowerCAmelCase_	,	required=lowerCAmelCase_	,	help="TensorFlow checkpoint path or folder."						)
				train_parser.add_argument(
				    "--pytorch_dump_output"	,	type=lowerCAmelCase_	,	required=lowerCAmelCase_	,	help="Path to the PyTorch saved model output."						)
				train_parser.add_argument("--config"	,	type=lowerCAmelCase_	,	default=""	,	help="Configuration file path or folder."						)
				train_parser.add_argument(
				    "--finetuning_task_name"	,	type=lowerCAmelCase_	,	default=lowerCAmelCase_	,	help="Optional fine-tuning task name if the TF model was a finetuned model."	,	)
				train_parser.set_defaults(func=lowerCAmelCase_						)





	def __init__(      self					: Optional[int]	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str	,	lowerCAmelCase_					: str	,	*lowerCAmelCase_					: Optional[int]	,	)						->			Tuple:
				UpperCAmelCase_     : List[Any]			     =					logging.get_logger("transformers-cli/converting"						)

				self._logger.info(f"""Loading model {model_type}"""						)
				UpperCAmelCase_     : Any			     =					model_type
				UpperCAmelCase_     : Dict			     =					tf_checkpoint
				UpperCAmelCase_     : Dict			     =					pytorch_dump_output
				UpperCAmelCase_     : str			     =					config
				UpperCAmelCase_     : Optional[int]			     =					finetuning_task_name





	def      _SCREAMING_SNAKE_CASE      (      self					: Optional[int]						)						->			Optional[Any]:
				if self._model_type == "albert":
							try:
										from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
										    convert_tf_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "bert":
							try:
										from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
										    convert_tf_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "funnel":
							try:
										from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
										    convert_tf_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "t5":
							try:
										from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "gpt":
							from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
							    convert_openai_checkpoint_to_pytorch,
							)

							convert_openai_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "transfo_xl":
							try:
										from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
										    convert_transfo_xl_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							if "ckpt" in self._tf_checkpoint.lower():
										UpperCAmelCase_     : Dict			     =					self._tf_checkpoint
										UpperCAmelCase_     : Optional[int]			     =					""
							else:
										UpperCAmelCase_     : str			     =					self._tf_checkpoint
										UpperCAmelCase_     : str			     =					""
							convert_transfo_xl_checkpoint_to_pytorch(
							    lowerCAmelCase_	,	self._config	,	self._pytorch_dump_output	,	lowerCAmelCase_						)
				elif self._model_type == "gpt2":
							try:
										from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
										    convert_gpta_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				elif self._model_type == "xlnet":
							try:
										from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
										    convert_xlnet_checkpoint_to_pytorch,
										)
							except ImportError:
										raise ImportError(lowerCAmelCase_						)

							convert_xlnet_checkpoint_to_pytorch(
							    self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output	,	self._finetuning_task_name						)
				elif self._model_type == "xlm":
							from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
							    convert_xlm_checkpoint_to_pytorch,
							)

							convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint	,	self._pytorch_dump_output						)
				elif self._model_type == "lxmert":
							from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
							    convert_lxmert_checkpoint_to_pytorch,
							)

							convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint	,	self._pytorch_dump_output						)
				elif self._model_type == "rembert":
							from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
							    convert_rembert_tf_checkpoint_to_pytorch,
							)

							convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint	,	self._config	,	self._pytorch_dump_output						)
				else:
							raise ValueError(
							    "--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]"						)











"""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())



