






'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCamelCase__ =			{
    'configuration_wav2vec2': ['WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Wav2Vec2Config'],
    'feature_extraction_wav2vec2': ['Wav2Vec2FeatureExtractor'],
    'processing_wav2vec2': ['Wav2Vec2Processor'],
    'tokenization_wav2vec2': ['Wav2Vec2CTCTokenizer', 'Wav2Vec2Tokenizer'],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCamelCase__ =			[
     'WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
     'Wav2Vec2ForAudioFrameClassification',
     'Wav2Vec2ForCTC',
     'Wav2Vec2ForMaskedLM',
     'Wav2Vec2ForPreTraining',
     'Wav2Vec2ForSequenceClassification',
     'Wav2Vec2ForXVector',
     'Wav2Vec2Model',
     'Wav2Vec2PreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCamelCase__ =			[
     'TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFWav2Vec2ForCTC',
     'TFWav2Vec2Model',
     'TFWav2Vec2PreTrainedModel',
     'TFWav2Vec2ForSequenceClassification',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCamelCase__ =			[
     'FlaxWav2Vec2ForCTC',
     'FlaxWav2Vec2ForPreTraining',
     'FlaxWav2Vec2Model',
     'FlaxWav2Vec2PreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
 from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
 from .processing_wavaveca import WavaVecaProcessor
 from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavaveca import (
      WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavaVecaForAudioFrameClassification,
      WavaVecaForCTC,
      WavaVecaForMaskedLM,
      WavaVecaForPreTraining,
      WavaVecaForSequenceClassification,
      WavaVecaForXVector,
      WavaVecaModel,
      WavaVecaPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_wavaveca import (
      TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFWavaVecaForCTC,
      TFWavaVecaForSequenceClassification,
      TFWavaVecaModel,
      TFWavaVecaPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_wavaveca import (
      FlaxWavaVecaForCTC,
      FlaxWavaVecaForPreTraining,
      FlaxWavaVecaModel,
      FlaxWavaVecaPreTrainedModel,
  )


else:
 import sys

 UpperCamelCase__ =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)












'''simple docstring'''
def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   def update_area_of_max_square(_UpperCamelCase						,		_UpperCamelCase							) -> int:
      # BASE CASE
      if row >= rows or col >= cols:
         return 0

      lowercase_	:    List[str]           =     update_area_of_max_square(_UpperCamelCase						,		col + 1							)
      lowercase_	:    List[Any]           =     update_area_of_max_square(row + 1						,		col + 1							)
      lowercase_	:    Tuple           =     update_area_of_max_square(row + 1						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Optional[int]           =     1 + min([right, diagonal, down]							)
         lowercase_	:    Any           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         return sub_problem_sol
      else:
         return 0

   lowercase_	:    int           =     [0]
   update_area_of_max_square(0						,		0							)
   return largest_square_area[0]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   def update_area_of_max_square_using_dp_array(
       _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							) -> int:
      if row >= rows or col >= cols:
         return 0
      if dp_array[row][col] != -1:
         return dp_array[row][col]

      lowercase_	:    Dict           =     update_area_of_max_square_using_dp_array(_UpperCamelCase						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    str           =     update_area_of_max_square_using_dp_array(row + 1						,		col + 1						,		_UpperCamelCase							)
      lowercase_	:    Optional[Any]           =     update_area_of_max_square_using_dp_array(row + 1						,		_UpperCamelCase						,		_UpperCamelCase							)

      if mat[row][col]:
         lowercase_	:    Tuple           =     1 + min([right, diagonal, down]							)
         lowercase_	:    int           =     max(largest_square_area[0]						,		_UpperCamelCase							)
         lowercase_	:    Dict           =     sub_problem_sol
         return sub_problem_sol
      else:
         return 0

   lowercase_	:    Any           =     [0]
   lowercase_	:    Optional[int]           =     [[-1] * cols for _ in range(_UpperCamelCase							)]
   update_area_of_max_square_using_dp_array(0						,		0						,		_UpperCamelCase							)

   return largest_square_area[0]




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    str           =     [[0] * (cols + 1) for _ in range(rows + 1							)]
   lowercase_	:    List[Any]           =     0
   for row in range(rows - 1						,		-1						,		-1							):
      for col in range(cols - 1						,		-1						,		-1							):
         lowercase_	:    Tuple           =     dp_array[row][col + 1]
         lowercase_	:    List[str]           =     dp_array[row + 1][col + 1]
         lowercase_	:    List[Any]           =     dp_array[row + 1][col]

         if mat[row][col] == 1:
            lowercase_	:    Any           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    Any           =     max(dp_array[row][col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    int           =     0

   return largest_square_area




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    Optional[int]           =     [0] * (cols + 1)
   lowercase_	:    Union[str, Any]           =     [0] * (cols + 1)
   lowercase_	:    int           =     0
   for row in range(rows - 1						,		-1						,		-1							):
      for col in range(cols - 1						,		-1						,		-1							):
         lowercase_	:    Dict           =     current_row[col + 1]
         lowercase_	:    List[Any]           =     next_row[col + 1]
         lowercase_	:    Tuple           =     next_row[col]

         if mat[row][col] == 1:
            lowercase_	:    Dict           =     1 + min(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
            lowercase_	:    int           =     max(current_row[col]						,		_UpperCamelCase							)
         else:
            lowercase_	:    Tuple           =     0
      lowercase_	:    Optional[Any]           =     current_row

   return largest_square_area


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))




