
"""simple docstring"""




import os



def     __magic_name__		(					UpperCamelCase     :		Union[str, Any]     )     ->						Optional[int]:
    a__		=			len(grid[0]     )
    a__		=			len(UpperCamelCase     )

    a__		=			0
    a__		=			0
    a__		=			0

    # Check vertically, horizontally, diagonally at the same time (only works
    # for nxn grid)
    for i in range(UpperCamelCase     ):
        for j in range(n_rows - 3     ):
            a__		=			grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
            a__		=			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:
                a__		=			(
                    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:
                a__		=			(
                    grid[i][j]
                    * grid[i - 1][j + 1]
                    * grid[i - 2][j + 2]
                    * grid[i - 3][j + 3]
                )

            a__		=			max(
                UpperCamelCase							,		UpperCamelCase							,		UpperCamelCase							,		UpperCamelCase     )
            if max_product > largest:
                a__		=			max_product

    return largest



def     __magic_name__		(					)     ->						List[Any]:
    a__		=			[]
    with open(os.path.dirname(UpperCamelCase     ) + '/grid.txt'     ) as file:
        for line in file:
            grid.append(line.strip('\n'     ).split(' '     )     )

    a__		=			[[int(UpperCamelCase     ) for i in grid[j]] for j in range(len(UpperCamelCase     )     )]

    return largest_product(UpperCamelCase     )


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




"""simple docstring"""




import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class     lowercase(_lowercase    ,						_lowercase    ,						unittest.TestCase       ):
     __snake_case:	Optional[int]						=     IFImgaImgSuperResolutionPipeline
     __snake_case:	Dict						=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     __snake_case:	Any						=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}       )
     __snake_case:	List[Any]						=     PipelineTesterMixin.required_optional_params - {'latents'}



     def 			lowercase__  (							self   )		->     Tuple:







         """simple docstring"""



         return self._get_superresolution_dummy_components()



     def 			lowercase__  (							self     ,				__SCREAMING_SNAKE_CASE     ,				__SCREAMING_SNAKE_CASE=0   )		->     Union[str, Any]:







         """simple docstring"""



         if str(__SCREAMING_SNAKE_CASE   ).startswith('mps'   ):
             a__		=			torch.manual_seed(__SCREAMING_SNAKE_CASE   )
         else:
             a__		=			torch.Generator(device=__SCREAMING_SNAKE_CASE   ).manual_seed(__SCREAMING_SNAKE_CASE   )

         a__		=			floats_tensor((1, 3, 3_2, 3_2)     ,				rng=random.Random(__SCREAMING_SNAKE_CASE   )   ).to(__SCREAMING_SNAKE_CASE   )
         a__		=			floats_tensor((1, 3, 1_6, 1_6)     ,				rng=random.Random(__SCREAMING_SNAKE_CASE   )   ).to(__SCREAMING_SNAKE_CASE   )

         a__		=			{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'original_image': original_image,
             'generator': generator,
             'num_inference_steps': 2,
             'output_type': 'numpy',
         }

         return inputs



     @unittest.skipIf(
         torch_device != 'cuda' or not is_xformers_available()     ,				reason='XFormers attention is only available with CUDA and `xformers` installed'     ,				)
     def 			lowercase__  (							self   )		->     Optional[int]:







         """simple docstring"""



         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3   )



     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         self._test_save_load_optional_components()



     @unittest.skipIf(torch_device != 'cuda'     ,				reason='float16 requires CUDA'   )
     def 			lowercase__  (							self   )		->     List[Any]:







         """simple docstring"""



         super().test_save_load_floataa(expected_max_diff=1e-1   )



     def 			lowercase__  (							self   )		->     List[str]:







         """simple docstring"""



         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2   )



     def 			lowercase__  (							self   )		->     Optional[Any]:







         """simple docstring"""



         self._test_save_load_local()




     def 			lowercase__  (							self   )		->     Any:







         """simple docstring"""



         self._test_inference_batch_single_identical(
             expected_max_diff=1e-2     ,				)


