'''simple docstring'''




from collections import defaultdict

from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst

def _UpperCamelCase   (       ):
     lowercase_				,lowercase_					:       Optional[int]     				=					9, 14  # noqa: F841
     lowercase_					:       str     				=					[
         [0, 1, 4],
         [0, 7, 8],
         [1, 2, 8],
         [7, 8, 7],
         [7, 6, 1],
         [2, 8, 2],
         [8, 6, 6],
         [2, 3, 7],
         [2, 5, 4],
         [6, 5, 2],
         [3, 5, 14],
         [3, 4, 9],
         [5, 4, 10],
         [1, 7, 11],
     ]

     lowercase_					:       List[Any]     				=					defaultdict(SCREAMING_SNAKE_CASE_							)
     for nodea, nodea, cost in edges:
          adjancency[nodea].append([nodea, cost]							)
          adjancency[nodea].append([nodea, cost]							)

     lowercase_					:       str     				=					mst(SCREAMING_SNAKE_CASE_							)

     lowercase_					:       Any     				=					[
         [7, 6, 1],
         [2, 8, 2],
         [6, 5, 2],
         [0, 1, 4],
         [2, 5, 4],
         [2, 3, 7],
         [0, 7, 8],
         [3, 4, 9],
     ]

     for answer in expected:
          lowercase_					:       List[Any]     				=					tuple(answer[:2]							)
          lowercase_					:       Tuple     				=					tuple(edge[::-1]							)
          assert edge in result or reverse in result





'''simple docstring'''




import os

def _UpperCamelCase   (       SCREAMING_SNAKE_CASE_							):
     lowercase_					:       List[Any]     				=					len(grid[0]							)
     lowercase_					:       Union[str, Any]     				=					len(SCREAMING_SNAKE_CASE_							)

     lowercase_					:       Union[str, Any]     				=					0
     lowercase_					:       int     				=					0
     lowercase_					:       Union[str, Any]     				=					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							):
               lowercase_					:       Dict     				=					grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
               lowercase_					:       Optional[Any]     				=					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:
                    lowercase_					:       Tuple     				=					(
                        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:
                    lowercase_					:       int     				=					(
                        grid[i][j]
                        * grid[i - 1][j + 1]
                        * grid[i - 2][j + 2]
                        * grid[i - 3][j + 3]
                    )

               lowercase_					:       Optional[int]     				=					max(
                   SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_  ,       SCREAMING_SNAKE_CASE_							)
               if max_product > largest:
                    lowercase_					:       List[Any]     				=					max_product

     return largest

def _UpperCamelCase   (       ):
     lowercase_					:       int     				=					[]
     with open(os.path.dirname(SCREAMING_SNAKE_CASE_							) + '/grid.txt'							) as file:
          for line in file:
               grid.append(line.strip('\n'							).split(' '							)							)

     lowercase_					:       Dict     				=					[[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())




