'''simple docstring'''

import os







def      UpperCamelCase_						(					snake_case_       :       Optional[Any]      )					->     Tuple:






 '''simple docstring'''

 __lowerCAmelCase											=						len(grid[0]      )
 __lowerCAmelCase											=						len(SCREAMING_SNAKE_CASE__      )

 __lowerCAmelCase											=						0
 __lowerCAmelCase											=						0
 __lowerCAmelCase											=						0

 # Check vertically, horizontally, diagonally at the same time (only works
 # for nxn grid)
 for i in range(SCREAMING_SNAKE_CASE__      ):
  for j in range(n_rows - 3      ):
   __lowerCAmelCase											=						grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
   __lowerCAmelCase											=						grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

   # Left-to-right diagonal (\) product
   if i < n_columns - 3:
    __lowerCAmelCase											=						(
        grid[i][j]
        * grid[i + 1][j + 1]
        * grid[i + 2][j + 2]
        * grid[i + 3][j + 3]
    )

   # Right-to-left diagonal(/) product
   if i > 2:
    __lowerCAmelCase											=						(
        grid[i][j]
        * grid[i - 1][j + 1]
        * grid[i - 2][j + 2]
        * grid[i - 3][j + 3]
    )

   __lowerCAmelCase											=						max(
       SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__						,		SCREAMING_SNAKE_CASE__      )
   if max_product > largest:
    __lowerCAmelCase											=						max_product

 return largest







def      UpperCamelCase_						(					)					->     Optional[Any]:






 '''simple docstring'''

 __lowerCAmelCase											=						[]
 with open(os.path.dirname(SCREAMING_SNAKE_CASE__      ) + """/grid.txt"""      ) as file:
  for line in file:
   grid.append(line.strip("""\n"""      ).split(""" """      )      )

 __lowerCAmelCase											=						[[int(SCREAMING_SNAKE_CASE__      ) for i in grid[j]] for j in range(len(SCREAMING_SNAKE_CASE__      )      )]

 return largest_product(SCREAMING_SNAKE_CASE__      )


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








import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY

@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class __snake_case		(      unittest.TestCase     ):
    _a		:						Optional[int]=				MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Any       	=      hf_hub_download(
               repo_id="""nateraw/video-demo"""		,filename="""archery.mp4"""		,repo_type="""dataset"""      )
           lowercase							:     List[str]       	=      VideoClassificationPipeline(model=snake_case		,image_processor=snake_case		,top_k=2      )
           lowercase							:     Dict       	=      [
               example_video_filepath,
               """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""",
           ]
           return video_classifier, examples
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case      ):



           '''simple docstring'''







           for example in examples:
                  lowercase							:     int       	=      video_classifier(snake_case      )

                  self.assertEqual(
                      snake_case		,[
                          {"""score""": ANY(snake_case      ), """label""": ANY(snake_case      )},
                          {"""score""": ANY(snake_case      ), """label""": ANY(snake_case      )},
                      ]		,)
    @require_torch
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Any       	=      """hf-internal-testing/tiny-random-VideoMAEForVideoClassification"""
           lowercase							:     str       	=      VideoMAEFeatureExtractor(
               size={"""shortest_edge""": 10}		,crop_size={"""height""": 10, """width""": 10}      )
           lowercase							:     List[Any]       	=      pipeline(
               """video-classification"""		,model=snake_case		,feature_extractor=snake_case		,frame_sampling_rate=4      )

           lowercase							:     Dict       	=      hf_hub_download(repo_id="""nateraw/video-demo"""		,filename="""archery.mp4"""		,repo_type="""dataset"""      )
           lowercase							:     Any       	=      video_classifier(snake_case		,top_k=2      )
           self.assertEqual(
               nested_simplify(snake_case		,decimals=4      )		,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}]		,)

           lowercase							:     str       	=      video_classifier(
               [
                   video_file_path,
                   video_file_path,
               ]		,top_k=2		,)
           self.assertEqual(
               nested_simplify(snake_case		,decimals=4      )		,[
                   [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
                   [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}],
               ]		,)
    @require_tf
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           pass
