





'''simple docstring'''




from __future__ import annotations

import math






def 			_lowerCAmelCase     (    __snake_case    :					list					,				__snake_case    :					list     )	->	list:
     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'     )
     __A		:					Optional[int]						=			[
         [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 			_lowerCAmelCase     (    __snake_case    :					list					,				__snake_case    :					list     )	->	List[str]:
     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 			_lowerCAmelCase     (    __snake_case    :					list					,				__snake_case    :					list     )	->	Tuple:
     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 			_lowerCAmelCase     (    __snake_case    :					list     )	->	tuple[list, list, list, list]:
     if len(__snake_case     ) % 2 != 0 or len(a[0]     ) % 2 != 0:
          raise Exception('Odd matrices are not supported!'     )

     __A		:					Dict						=			len(__snake_case     )
     __A		:					Dict						=			matrix_length // 2

     __A		:					str						=			[[a[i][j] for j in range(__snake_case					,				__snake_case     )] for i in range(__snake_case     )]
     __A		:					Dict						=			[
         [a[i][j] for j in range(__snake_case					,				__snake_case     )] for i in range(__snake_case					,				__snake_case     )
     ]

     __A		:					int						=			[[a[i][j] for j in range(__snake_case     )] for i in range(__snake_case     )]
     __A		:					int						=			[[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 			_lowerCAmelCase     (    __snake_case    :					list     )	->	tuple[int, int]:
     return len(__snake_case     ), len(matrix[0]     )






def 			_lowerCAmelCase     (    __snake_case    :					list     )	->	None:
     print('\n'.join(str(__snake_case     ) for line in matrix     )     )






def 			_lowerCAmelCase     (    __snake_case    :					list					,				__snake_case    :					list     )	->	list:
     if matrix_dimensions(__snake_case     ) == (2, 2):
          return default_matrix_multiplication(__snake_case					,				__snake_case     )

     __A					,__A					,__A					,__A		:					Any						=			split_matrix(__snake_case     )
     __A					,__A					,__A					,__A		:					int						=			split_matrix(__snake_case     )

     __A		:					Union[str, Any]						=			actual_strassen(__snake_case					,				matrix_subtraction(__snake_case					,				__snake_case     )     )
     __A		:					str						=			actual_strassen(matrix_addition(__snake_case					,				__snake_case     )					,				__snake_case     )
     __A		:					Tuple						=			actual_strassen(matrix_addition(__snake_case					,				__snake_case     )					,				__snake_case     )
     __A		:					List[Any]						=			actual_strassen(__snake_case					,				matrix_subtraction(__snake_case					,				__snake_case     )     )
     __A		:					Any						=			actual_strassen(matrix_addition(__snake_case					,				__snake_case     )					,				matrix_addition(__snake_case					,				__snake_case     )     )
     __A		:					Optional[int]						=			actual_strassen(matrix_subtraction(__snake_case					,				__snake_case     )					,				matrix_addition(__snake_case					,				__snake_case     )     )
     __A		:					Optional[int]						=			actual_strassen(matrix_subtraction(__snake_case					,				__snake_case     )					,				matrix_addition(__snake_case					,				__snake_case     )     )

     __A		:					str						=			matrix_addition(matrix_subtraction(matrix_addition(__snake_case					,				__snake_case     )					,				__snake_case     )					,				__snake_case     )
     __A		:					int						=			matrix_addition(__snake_case					,				__snake_case     )
     __A		:					Optional[Any]						=			matrix_addition(__snake_case					,				__snake_case     )
     __A		:					List[Any]						=			matrix_subtraction(matrix_subtraction(matrix_addition(__snake_case					,				__snake_case     )					,				__snake_case     )					,				__snake_case     )

     # construct the new matrix from our 4 quadrants
     __A		:					Union[str, Any]						=			[]
     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 			_lowerCAmelCase     (    __snake_case    :					list					,				__snake_case    :					list     )	->	list:
     if matrix_dimensions(__snake_case     )[1] != matrix_dimensions(__snake_case     )[0]:
          __A		:					Union[str, Any]						=			(
              'Unable to multiply these matrices, please check the dimensions.\n'
              f'Matrix A: {matrixa}\n'
              f'Matrix B: {matrixa}'
          )
          raise Exception(__snake_case     )
     __A		:					Optional[int]						=			matrix_dimensions(__snake_case     )
     __A		:					Tuple						=			matrix_dimensions(__snake_case     )

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

     __A		:					Union[str, Any]						=			max(*__snake_case					,				*__snake_case     )
     __A		:					Any						=			int(math.pow(2					,				math.ceil(math.loga(__snake_case     )     )     )     )
     __A		:					Any						=			matrixa
     __A		:					str						=			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     )

     __A		:					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__":
  lowercase__       : Any         =       [
      [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],
  ]
  lowercase__       : Tuple         =       [[0, 2, 1, 1], [16, 2, 3, 3], [2, 2, 7, 7], [13, 11, 22, 4]]
  print(strassen(matrixa, matrixa))






'''simple docstring'''




def 			_lowerCAmelCase     (    __snake_case    :					str					,				__snake_case    :					str     )	->	int:
     if len(__snake_case     ) != len(__snake_case     ):
          raise ValueError('String lengths must match!'     )

     __A		:					Optional[Any]						=			0

     for chara, chara in zip(__snake_case					,				__snake_case     ):
          if chara != chara:
               count += 1

     return count


if __name__ == "__main__":
  import doctest

  doctest.testmod()