




'''simple docstring'''


import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


UpperCAmelCase_ 		=      random.Random()


def 						SCREAMING_SNAKE_CASE       (      a_	:							Union[str, Any]				,					a_	:							Optional[int]=1.0				,					a_	:							Dict=None				,					a_	:							Tuple=None			):
  if rng is None:
    __a			=					global_rng

  __a			=					[]
  for batch_idx in range(shape[0]			):
    values.append([]			)
    for _ in range(shape[1]			):
      values[-1].append(rng.random() * scale			)

  return values





@require_torch
class    __lowercase						(  unittest.TestCase ):







   def __init__(	self      ,							UpperCamelCase      ,							UpperCamelCase=7      ,							UpperCamelCase=400      ,							UpperCamelCase=2000      ,							UpperCamelCase=1      ,							UpperCamelCase=0.0      ,							UpperCamelCase=1_6000      ,							UpperCamelCase=True      ,							UpperCamelCase=80      ,							UpperCamelCase=16      ,							UpperCamelCase=64      ,							UpperCamelCase="hann_window"      ,							UpperCamelCase=80      ,							UpperCamelCase=7600      ,							UpperCamelCase=1e-10      ,							UpperCamelCase=True      ,							)				->    Optional[Any]:
     __a			=					parent
     __a			=					batch_size
     __a			=					min_seq_length
     __a			=					max_seq_length
     __a			=					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     __a			=					feature_size
     __a			=					padding_value
     __a			=					sampling_rate
     __a			=					do_normalize
     __a			=					num_mel_bins
     __a			=					hop_length
     __a			=					win_length
     __a			=					win_function
     __a			=					fmin
     __a			=					fmax
     __a			=					mel_floor
     __a			=					return_attention_mask







   def 		UpperCamelCase__			(	self      )				->    Optional[Any]:
     return {
         "feature_size": self.feature_size,
         "padding_value": self.padding_value,
         "sampling_rate": self.sampling_rate,
         "do_normalize": self.do_normalize,
         "num_mel_bins": self.num_mel_bins,
         "hop_length": self.hop_length,
         "win_length": self.win_length,
         "win_function": self.win_function,
         "fmin": self.fmin,
         "fmax": self.fmax,
         "mel_floor": self.mel_floor,
         "return_attention_mask": self.return_attention_mask,
     }







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase=False      ,							UpperCamelCase=False      )				->    Dict:
     def _flatten(UpperCamelCase      ):
       return list(itertools.chain(*UpperCamelCase      )      )

     if equal_length:
       __a			=					floats_list((self.batch_size, self.max_seq_length)      )
     else:
       # make sure that inputs increase in size
       __a			=					[
           _flatten(floats_list((x, self.feature_size)      )      )
           for x in range(self.min_seq_length      ,							self.max_seq_length      ,							self.seq_length_diff      )
       ]

     if numpify:
       __a			=					[np.asarray(UpperCamelCase      ) for x in speech_inputs]

     return speech_inputs







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase=False      ,							UpperCamelCase=False      )				->    Optional[int]:
     if equal_length:
       __a			=					[floats_list((self.max_seq_length, self.num_mel_bins)      ) for _ in range(self.batch_size      )]
     else:
       # make sure that inputs increase in size
       __a			=					[
           floats_list((x, self.num_mel_bins)      )
           for x in range(self.min_seq_length      ,							self.max_seq_length      ,							self.seq_length_diff      )
       ]

     if numpify:
       __a			=					[np.asarray(UpperCamelCase      ) for x in speech_inputs]

     return speech_inputs





@require_torch
class    __lowercase						(  __magic_name__       ,							unittest.TestCase ):
   _a							=      SpeechTaFeatureExtractor







   def 		UpperCamelCase__			(	self      )				->    List[str]:
     __a			=					SpeechTaFeatureExtractionTester(self      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      )				->    List[Any]:
     self.assertTrue(np.all(np.mean(UpperCamelCase      ,							axis=0      ) < 1e-3      )      )
     self.assertTrue(np.all(np.abs(np.var(UpperCamelCase      ,							axis=0      ) - 1      ) < 1e-3      )      )







   def 		UpperCamelCase__			(	self      )				->    Dict:
     # Tests that all call wrap to encode_plus and batch_encode_plus
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     # create three inputs of length 800, 1000, and 1200
     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]
     __a			=					[np.asarray(UpperCamelCase      ) for speech_input in speech_inputs]

     # Test not batched input
     __a			=					feat_extract(speech_inputs[0]      ,							return_tensors='np'      ).input_values
     __a			=					feat_extract(np_speech_inputs[0]      ,							return_tensors='np'      ).input_values
     self.assertTrue(np.allclose(UpperCamelCase      ,							UpperCamelCase      ,							atol=1e-3      )      )

     # Test batched
     __a			=					feat_extract(UpperCamelCase      ,							return_tensors='np'      ).input_values
     __a			=					feat_extract(UpperCamelCase      ,							return_tensors='np'      ).input_values
     for enc_seq_a, enc_seq_a in zip(UpperCamelCase      ,							UpperCamelCase      ):
       self.assertTrue(np.allclose(UpperCamelCase      ,							UpperCamelCase      ,							atol=1e-3      )      )







   def 		UpperCamelCase__			(	self      )				->    List[Any]:
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]

     __a			=					['longest', 'max_length', 'do_not_pad']
     __a			=					[None, 1600, None]
     for max_length, padding in zip(UpperCamelCase      ,							UpperCamelCase      ):
       __a			=					feat_extract(UpperCamelCase      ,							padding=UpperCamelCase      ,							max_length=UpperCamelCase      ,							return_tensors='np'      )
       __a			=					processed.input_values

       self._check_zero_mean_unit_variance(input_values[0][:800]      )
       self.assertTrue(input_values[0][800:].sum() < 1e-6      )
       self._check_zero_mean_unit_variance(input_values[1][:1000]      )
       self.assertTrue(input_values[0][1000:].sum() < 1e-6      )
       self._check_zero_mean_unit_variance(input_values[2][:1200]      )







   def 		UpperCamelCase__			(	self      )				->    List[Any]:
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     __a			=					range(800      ,							1400      ,							200      )
     __a			=					[floats_list((1, x)      )[0] for x in lengths]

     __a			=					['longest', 'max_length', 'do_not_pad']
     __a			=					[None, 1600, None]

     for max_length, padding in zip(UpperCamelCase      ,							UpperCamelCase      ):
       __a			=					feat_extract(UpperCamelCase      ,							max_length=UpperCamelCase      ,							padding=UpperCamelCase      )
       __a			=					processed.input_values

       self._check_zero_mean_unit_variance(input_values[0][:800]      )
       self._check_zero_mean_unit_variance(input_values[1][:1000]      )
       self._check_zero_mean_unit_variance(input_values[2][:1200]      )







   def 		UpperCamelCase__			(	self      )				->    Tuple:
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]
     __a			=					feat_extract(
         UpperCamelCase      ,							truncation=UpperCamelCase      ,							max_length=1000      ,							padding='max_length'      ,							return_tensors='np'      )
     __a			=					processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :800]      )
     self._check_zero_mean_unit_variance(input_values[1]      )
     self._check_zero_mean_unit_variance(input_values[2]      )







   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]
     __a			=					feat_extract(
         UpperCamelCase      ,							truncation=UpperCamelCase      ,							max_length=1000      ,							padding='longest'      ,							return_tensors='np'      )
     __a			=					processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :800]      )
     self._check_zero_mean_unit_variance(input_values[1, :1000]      )
     self._check_zero_mean_unit_variance(input_values[2]      )

     # make sure that if max_length < longest -> then pad to max_length
     self.assertTrue(input_values.shape == (3, 1000)      )

     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]
     __a			=					feat_extract(
         UpperCamelCase      ,							truncation=UpperCamelCase      ,							max_length=2000      ,							padding='longest'      ,							return_tensors='np'      )
     __a			=					processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :800]      )
     self._check_zero_mean_unit_variance(input_values[1, :1000]      )
     self._check_zero_mean_unit_variance(input_values[2]      )

     # make sure that if max_length > longest -> then pad to longest
     self.assertTrue(input_values.shape == (3, 1200)      )







   def 		UpperCamelCase__			(	self      )				->    str:
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     __a			=					np.random.rand(100      ).astype(np.floataa      )
     __a			=					np_speech_inputs.tolist()

     for inputs in [py_speech_inputs, np_speech_inputs]:
       __a			=					feature_extractor.pad([{'input_values': inputs}]      ,							return_tensors='np'      )
       self.assertTrue(np_processed.input_values.dtype == np.floataa      )
       __a			=					feature_extractor.pad([{'input_values': inputs}]      ,							return_tensors='pt'      )
       self.assertTrue(pt_processed.input_values.dtype == torch.floataa      )







   def 		UpperCamelCase__			(	self      )				->    Union[str, Any]:
     # Tests that all call wrap to encode_plus and batch_encode_plus
     __a			=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
     # create three inputs of length 800, 1000, and 1200
     __a			=					[floats_list((1, x)      )[0] for x in range(800      ,							1400      ,							200      )]
     __a			=					[np.asarray(UpperCamelCase      ) for speech_input in speech_inputs]

     # Test feature size
     __a			=					feature_extractor(audio_target=UpperCamelCase      ,							padding=UpperCamelCase      ,							return_tensors='np'      ).input_values
     self.assertTrue(input_values.ndim == 3      )
     self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins      )

     # Test not batched input
     __a			=					feature_extractor(speech_inputs[0]      ,							return_tensors='np'      ).input_values
     __a			=					feature_extractor(np_speech_inputs[0]      ,							return_tensors='np'      ).input_values
     self.assertTrue(np.allclose(UpperCamelCase      ,							UpperCamelCase      ,							atol=1e-3      )      )

     # Test batched
     __a			=					feature_extractor(UpperCamelCase      ,							return_tensors='np'      ).input_values
     __a			=					feature_extractor(UpperCamelCase      ,							return_tensors='np'      ).input_values
     for enc_seq_a, enc_seq_a in zip(UpperCamelCase      ,							UpperCamelCase      ):
       self.assertTrue(np.allclose(UpperCamelCase      ,							UpperCamelCase      ,							atol=1e-3      )      )

     # Test 2-D numpy arrays are batched.
     __a			=					[floats_list((1, x)      )[0] for x in (800, 800, 800)]
     __a			=					np.asarray(UpperCamelCase      )
     __a			=					feature_extractor(UpperCamelCase      ,							return_tensors='np'      ).input_values
     __a			=					feature_extractor(UpperCamelCase      ,							return_tensors='np'      ).input_values
     for enc_seq_a, enc_seq_a in zip(UpperCamelCase      ,							UpperCamelCase      ):
       self.assertTrue(np.allclose(UpperCamelCase      ,							UpperCamelCase      ,							atol=1e-3      )      )







   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     __a			=					self.feat_extract_tester.prepare_inputs_for_target()
     __a			=					self.feature_extraction_class(**self.feat_extract_dict      )
     __a			=					feat_extract.model_input_names[0]

     __a			=					BatchFeature({input_name: speech_inputs}      )

     self.assertTrue(all(len(UpperCamelCase      ) == len(UpperCamelCase      ) for x, y in zip(UpperCamelCase      ,							processed_features[input_name]      )      )      )

     __a			=					self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase      )
     __a			=					BatchFeature({input_name: speech_inputs}      ,							tensor_type='np'      )

     __a			=					processed_features[input_name]

     if len(batch_features_input.shape      ) < 3:
       __a			=					batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]      ), self.feat_extract_tester.num_mel_bins)      )







   @require_torch
   def 		UpperCamelCase__			(	self      )				->    List[str]:
     __a			=					self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase      )
     __a			=					self.feature_extraction_class(**self.feat_extract_dict      )
     __a			=					feat_extract.model_input_names[0]

     __a			=					BatchFeature({input_name: speech_inputs}      ,							tensor_type='pt'      )

     __a			=					processed_features[input_name]

     if len(batch_features_input.shape      ) < 3:
       __a			=					batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]      ), self.feat_extract_tester.num_mel_bins)      )







   @require_torch
   def 		UpperCamelCase__			(	self      )				->    Any:
     __a			=					self.feature_extraction_class(**self.feat_extract_dict      )
     __a			=					self.feat_extract_tester.prepare_inputs_for_target()
     __a			=					feat_extract.model_input_names[0]

     __a			=					BatchFeature({input_name: speech_inputs}      )

     __a			=					feat_extract.num_mel_bins  # hack!

     __a			=					feat_extract.pad(UpperCamelCase      ,							padding='longest'      ,							return_tensors='np'      )[input_name]
     __a			=					feat_extract.pad(UpperCamelCase      ,							padding='longest'      ,							return_tensors='pt'      )[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa      ).sum() - input_pt.numpy().astype(np.floataa      ).sum()      ) < 1e-2      )







   def 		UpperCamelCase__			(	self      )				->    int:
     __a			=					self.feat_extract_dict
     __a			=					True
     __a			=					self.feature_extraction_class(**UpperCamelCase      )
     __a			=					self.feat_extract_tester.prepare_inputs_for_target()
     __a			=					[len(UpperCamelCase      ) for x in speech_inputs]
     __a			=					feat_extract.model_input_names[0]

     __a			=					BatchFeature({input_name: speech_inputs}      )

     __a			=					feat_extract.num_mel_bins  # hack!

     __a			=					feat_extract.pad(UpperCamelCase      ,							padding='longest'      ,							return_tensors='np'      )
     self.assertIn('attention_mask'      ,							UpperCamelCase      )
     self.assertListEqual(list(processed.attention_mask.shape      )      ,							list(processed[input_name].shape[:2]      )      )
     self.assertListEqual(processed.attention_mask.sum(-1      ).tolist()      ,							UpperCamelCase      )







   def 		UpperCamelCase__			(	self      )				->    str:
     __a			=					self.feat_extract_dict
     __a			=					True
     __a			=					self.feature_extraction_class(**UpperCamelCase      )
     __a			=					self.feat_extract_tester.prepare_inputs_for_target()
     __a			=					[len(UpperCamelCase      ) for x in speech_inputs]
     __a			=					feat_extract.model_input_names[0]

     __a			=					BatchFeature({input_name: speech_inputs}      )
     __a			=					min(UpperCamelCase      )

     __a			=					feat_extract.num_mel_bins  # hack!

     __a			=					feat_extract.pad(
         UpperCamelCase      ,							padding='max_length'      ,							max_length=UpperCamelCase      ,							truncation=UpperCamelCase      ,							return_tensors='np'      )
     self.assertIn('attention_mask'      ,							UpperCamelCase      )
     self.assertListEqual(
         list(processed_pad.attention_mask.shape      )      ,							[processed_pad[input_name].shape[0], max_length]      )
     self.assertListEqual(
         processed_pad.attention_mask[:, :max_length].sum(-1      ).tolist()      ,							[max_length for x in speech_inputs]      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      )				->    Union[str, Any]:
     from datasets import load_dataset

     __a			=					load_dataset('hf-internal-testing/librispeech_asr_dummy'      ,							'clean'      ,							split='validation'      )
     # automatic decoding with librispeech
     __a			=					ds.sort('id'      ).select(range(UpperCamelCase      )      )[:num_samples]['audio']

     return [x["array"] for x in speech_samples]







   def 		UpperCamelCase__			(	self      )				->    int:
     # fmt: off
     __a			=					torch.tensor(
         [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
          3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
          2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
          4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
          7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
          4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]      )
     # fmt: on

     __a			=					self._load_datasamples(1      )
     __a			=					SpeechTaFeatureExtractor()
     __a			=					feature_extractor(UpperCamelCase      ,							return_tensors='pt'      ).input_values
     self.assertEquals(input_values.shape      ,							(1, 9_3680)      )
     self.assertTrue(torch.allclose(input_values[0, :30]      ,							UpperCamelCase      ,							atol=1e-6      )      )







   def 		UpperCamelCase__			(	self      )				->    Optional[int]:
     # fmt: off
     __a			=					torch.tensor(
         [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
          -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
          -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
          -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]      )
     # fmt: on

     __a			=					self._load_datasamples(1      )
     __a			=					SpeechTaFeatureExtractor()
     __a			=					feature_extractor(audio_target=UpperCamelCase      ,							return_tensors='pt'      ).input_values
     self.assertEquals(input_values.shape      ,							(1, 366, 80)      )
     self.assertTrue(torch.allclose(input_values[0, 0, :30]      ,							UpperCamelCase      ,							atol=1e-4      )      )









'''simple docstring'''


import os


def 						SCREAMING_SNAKE_CASE       (      ):
  with open(os.path.dirname(a_			) + '/grid.txt'			) as f:
    __a			=					[]  # noqa: E741
    for _ in range(20			):
      l.append([int(a_			) for x in f.readline().split()]			)

    __a			=					0

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

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

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

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


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



