



from __future__ import annotations

import math







def    _snake_case (       __snake_case					,  __snake_case    )     ->     list:






      '''simple docstring'''







      if len(__snake_case    ) != 2 or len(a[0]    ) != 2 or len(__snake_case    ) != 2 or len(b[0]    ) != 2:
            raise Exception("Matrices are not 2x2"    )
      UpperCAmelCase_  :	List[Any]				      =		[
          [a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],
          [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]],
      ]
      return new_matrix







def    _snake_case (       __snake_case					,  __snake_case    )     ->     Union[str, Any]:






      '''simple docstring'''







      return [
          [matrix_a[row][col] + matrix_b[row][col] for col in range(len(matrix_a[row]    )    )]
          for row in range(len(__snake_case    )    )
      ]







def    _snake_case (       __snake_case					,  __snake_case    )     ->     Optional[int]:






      '''simple docstring'''







      return [
          [matrix_a[row][col] - matrix_b[row][col] for col in range(len(matrix_a[row]    )    )]
          for row in range(len(__snake_case    )    )
      ]







def    _snake_case (       __snake_case    )     ->     tuple[list, list, list, list]:






      '''simple docstring'''







      if len(__snake_case    ) % 2 != 0 or len(a[0]    ) % 2 != 0:
            raise Exception("Odd matrices are not supported!"    )

      UpperCAmelCase_  :	Dict				      =		len(__snake_case    )
      UpperCAmelCase_  :	str				      =		matrix_length // 2

      UpperCAmelCase_  :	Optional[int]				      =		[[a[i][j] for j in range(__snake_case					,  __snake_case    )] for i in range(__snake_case    )]
      UpperCAmelCase_  :	int				      =		[
          [a[i][j] for j in range(__snake_case					,  __snake_case    )] for i in range(__snake_case					,  __snake_case    )
      ]

      UpperCAmelCase_  :	List[Any]				      =		[[a[i][j] for j in range(__snake_case    )] for i in range(__snake_case    )]
      UpperCAmelCase_  :	Optional[Any]				      =		[[a[i][j] for j in range(__snake_case    )] for i in range(__snake_case					,  __snake_case    )]

      return top_left, top_right, bot_left, bot_right







def    _snake_case (       __snake_case    )     ->     tuple[int, int]:






      '''simple docstring'''







      return len(__snake_case    ), len(matrix[0]    )







def    _snake_case (       __snake_case    )     ->     None:






      '''simple docstring'''







      print("\n".join(str(__snake_case    ) for line in matrix    )    )







def    _snake_case (       __snake_case					,  __snake_case    )     ->     list:






      '''simple docstring'''







      if matrix_dimensions(__snake_case    ) == (2, 2):
            return default_matrix_multiplication(__snake_case					,  __snake_case    )

      UpperCAmelCase_  :	str				      =		split_matrix(__snake_case    )
      UpperCAmelCase_  :	Dict				      =		split_matrix(__snake_case    )

      UpperCAmelCase_  :	str				      =		actual_strassen(__snake_case					,  matrix_subtraction(__snake_case					,  __snake_case    )    )
      UpperCAmelCase_  :	Any				      =		actual_strassen(matrix_addition(__snake_case					,  __snake_case    )					,  __snake_case    )
      UpperCAmelCase_  :	Optional[int]				      =		actual_strassen(matrix_addition(__snake_case					,  __snake_case    )					,  __snake_case    )
      UpperCAmelCase_  :	List[str]				      =		actual_strassen(__snake_case					,  matrix_subtraction(__snake_case					,  __snake_case    )    )
      UpperCAmelCase_  :	Dict				      =		actual_strassen(matrix_addition(__snake_case					,  __snake_case    )					,  matrix_addition(__snake_case					,  __snake_case    )    )
      UpperCAmelCase_  :	List[Any]				      =		actual_strassen(matrix_subtraction(__snake_case					,  __snake_case    )					,  matrix_addition(__snake_case					,  __snake_case    )    )
      UpperCAmelCase_  :	str				      =		actual_strassen(matrix_subtraction(__snake_case					,  __snake_case    )					,  matrix_addition(__snake_case					,  __snake_case    )    )

      UpperCAmelCase_  :	Union[str, Any]				      =		matrix_addition(matrix_subtraction(matrix_addition(__snake_case					,  __snake_case    )					,  __snake_case    )					,  __snake_case    )
      UpperCAmelCase_  :	List[str]				      =		matrix_addition(__snake_case					,  __snake_case    )
      UpperCAmelCase_  :	str				      =		matrix_addition(__snake_case					,  __snake_case    )
      UpperCAmelCase_  :	Tuple				      =		matrix_subtraction(matrix_subtraction(matrix_addition(__snake_case					,  __snake_case    )					,  __snake_case    )					,  __snake_case    )

      # construct the new matrix from our 4 quadrants
      UpperCAmelCase_  :	Optional[int]				      =		[]
      for i in range(len(__snake_case    )    ):
            new_matrix.append(top_left[i] + top_right[i]    )
      for i in range(len(__snake_case    )    ):
            new_matrix.append(bot_left[i] + bot_right[i]    )
      return new_matrix







def    _snake_case (       __snake_case					,  __snake_case    )     ->     list:






      '''simple docstring'''







      if matrix_dimensions(__snake_case    )[1] != matrix_dimensions(__snake_case    )[0]:
            UpperCAmelCase_  :	Tuple				      =		(
                "Unable to multiply these matrices, please check the dimensions.\n"
                F"""Matrix A: {matrixa}\n"""
                F"""Matrix B: {matrixa}"""
            )
            raise Exception(__snake_case    )
      UpperCAmelCase_  :	Optional[Any]				      =		matrix_dimensions(__snake_case    )
      UpperCAmelCase_  :	List[Any]				      =		matrix_dimensions(__snake_case    )

      if dimensiona[0] == dimensiona[1] and dimensiona[0] == dimensiona[1]:
            return [matrixa, matrixa]

      UpperCAmelCase_  :	Dict				      =		max(*__snake_case					,  *__snake_case    )
      UpperCAmelCase_  :	Tuple				      =		int(math.pow(2					,  math.ceil(math.loga(__snake_case    )    )    )    )
      UpperCAmelCase_  :	str				      =		matrixa
      UpperCAmelCase_  :	Tuple				      =		matrixa

      # Adding zeros to the matrices so that the arrays dimensions are the same and also
      # power of 2
      for i in range(0					,  __snake_case    ):
            if i < dimensiona[0]:
                  for _ in range(dimensiona[1]					,  __snake_case    ):
                        new_matrixa[i].append(0    )
            else:
                  new_matrixa.append([0] * maxim    )
            if i < dimensiona[0]:
                  for _ in range(dimensiona[1]					,  __snake_case    ):
                        new_matrixa[i].append(0    )
            else:
                  new_matrixa.append([0] * maxim    )

      UpperCAmelCase_  :	Optional[Any]				      =		actual_strassen(__snake_case					,  __snake_case    )

      # Removing the additional zeros
      for i in range(0					,  __snake_case    ):
            if i < dimensiona[0]:
                  for _ in range(dimensiona[1]					,  __snake_case    ):
                        final_matrix[i].pop()
            else:
                  final_matrix.pop()
      return final_matrix


if __name__ == "__main__":
   __lowerCamelCase  =			[
       [2, 3, 4, 5],
       [6, 4, 3, 1],
       [2, 3, 6, 7],
       [3, 1, 2, 4],
       [2, 3, 4, 5],
       [6, 4, 3, 1],
       [2, 3, 6, 7],
       [3, 1, 2, 4],
       [2, 3, 4, 5],
       [6, 2, 3, 1],
   ]
   __lowerCamelCase  =			[[0, 2, 1, 1], [16, 2, 3, 3], [2, 2, 7, 7], [13, 11, 22, 4]]
   print(strassen(matrixa, matrixa))





from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase         =			logging.get_logger(__name__)

__lowerCamelCase         =			{
    '''microsoft/trocr-base-handwritten''': (
        '''https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json'''
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}


class   snake_case_ (lowercase__  ):




       """simple docstring"""






       _lowerCamelCase			    =				"""trocr"""
       _lowerCamelCase			    =				["""past_key_values"""]
       _lowerCamelCase			    =				{
           """num_attention_heads""": """decoder_attention_heads""",
           """hidden_size""": """d_model""",
           """num_hidden_layers""": """decoder_layers""",
       }



       def __init__(     self     ,lowercase=50265     ,lowercase=1024     ,lowercase=12     ,lowercase=16     ,lowercase=4096     ,lowercase="gelu"     ,lowercase=512     ,lowercase=0.1     ,lowercase=0.0     ,lowercase=0.0     ,lowercase=2     ,lowercase=0.02     ,lowercase=0.0     ,lowercase=True     ,lowercase=False     ,lowercase=True     ,lowercase=True     ,lowercase=1     ,lowercase=0     ,lowercase=2     ,**lowercase     ,):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		vocab_size
             UpperCAmelCase_  :	Tuple				      =		d_model
             UpperCAmelCase_  :	List[str]				      =		decoder_layers
             UpperCAmelCase_  :	Union[str, Any]				      =		decoder_attention_heads
             UpperCAmelCase_  :	Optional[Any]				      =		decoder_ffn_dim
             UpperCAmelCase_  :	Tuple				      =		activation_function
             UpperCAmelCase_  :	List[Any]				      =		max_position_embeddings
             UpperCAmelCase_  :	List[Any]				      =		dropout
             UpperCAmelCase_  :	List[str]				      =		attention_dropout
             UpperCAmelCase_  :	Union[str, Any]				      =		activation_dropout
             UpperCAmelCase_  :	Optional[int]				      =		init_std
             UpperCAmelCase_  :	Dict				      =		decoder_layerdrop
             UpperCAmelCase_  :	List[str]				      =		use_cache
             UpperCAmelCase_  :	Dict				      =		scale_embedding
             UpperCAmelCase_  :	Dict				      =		use_learned_position_embeddings
             UpperCAmelCase_  :	Optional[Any]				      =		layernorm_embedding

             super().__init__(
                 pad_token_id=lowercase     ,bos_token_id=lowercase     ,eos_token_id=lowercase     ,decoder_start_token_id=lowercase     ,**lowercase     ,)
