




from __future__ import annotations

import math







def 		_A(       UpperCamelCase__							:			list				,       UpperCamelCase__							:			list				)    -> list:
       '''simple docstring'''


       if len(UpperCamelCase__				) != 2 or len(a[0]				) != 2 or len(UpperCamelCase__				) != 2 or len(b[0]				) != 2:
              raise Exception('''Matrices are not 2x2'''				)
       __lowercase      =    [
           [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 		_A(       UpperCamelCase__							:			list				,       UpperCamelCase__							:			list				)    -> 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(UpperCamelCase__				)				)
       ]







def 		_A(       UpperCamelCase__							:			list				,       UpperCamelCase__							:			list				)    -> List[str]:
       '''simple docstring'''


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







def 		_A(       UpperCamelCase__							:			list				)    -> tuple[list, list, list, list]:
       '''simple docstring'''


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

       __lowercase      =    len(UpperCamelCase__				)
       __lowercase      =    matrix_length // 2

       __lowercase      =    [[a[i][j] for j in range(UpperCamelCase__				,       UpperCamelCase__				)] for i in range(UpperCamelCase__				)]
       __lowercase      =    [
           [a[i][j] for j in range(UpperCamelCase__				,       UpperCamelCase__				)] for i in range(UpperCamelCase__				,       UpperCamelCase__				)
       ]

       __lowercase      =    [[a[i][j] for j in range(UpperCamelCase__				)] for i in range(UpperCamelCase__				)]
       __lowercase      =    [[a[i][j] for j in range(UpperCamelCase__				)] for i in range(UpperCamelCase__				,       UpperCamelCase__				)]

       return top_left, top_right, bot_left, bot_right







def 		_A(       UpperCamelCase__							:			list				)    -> tuple[int, int]:
       '''simple docstring'''


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







def 		_A(       UpperCamelCase__							:			list				)    -> None:
       '''simple docstring'''


       print('''\n'''.join(str(UpperCamelCase__				) for line in matrix				)				)







def 		_A(       UpperCamelCase__							:			list				,       UpperCamelCase__							:			list				)    -> list:
       '''simple docstring'''


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

       __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase      =    split_matrix(UpperCamelCase__				)
       __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase      =    split_matrix(UpperCamelCase__				)

       __lowercase      =    actual_strassen(UpperCamelCase__				,       matrix_subtraction(UpperCamelCase__				,       UpperCamelCase__				)				)
       __lowercase      =    actual_strassen(matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				,       UpperCamelCase__				)
       __lowercase      =    actual_strassen(matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				,       UpperCamelCase__				)
       __lowercase      =    actual_strassen(UpperCamelCase__				,       matrix_subtraction(UpperCamelCase__				,       UpperCamelCase__				)				)
       __lowercase      =    actual_strassen(matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				,       matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				)
       __lowercase      =    actual_strassen(matrix_subtraction(UpperCamelCase__				,       UpperCamelCase__				)				,       matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				)
       __lowercase      =    actual_strassen(matrix_subtraction(UpperCamelCase__				,       UpperCamelCase__				)				,       matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				)

       __lowercase      =    matrix_addition(matrix_subtraction(matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				,       UpperCamelCase__				)				,       UpperCamelCase__				)
       __lowercase      =    matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)
       __lowercase      =    matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)
       __lowercase      =    matrix_subtraction(matrix_subtraction(matrix_addition(UpperCamelCase__				,       UpperCamelCase__				)				,       UpperCamelCase__				)				,       UpperCamelCase__				)

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







def 		_A(       UpperCamelCase__							:			list				,       UpperCamelCase__							:			list				)    -> list:
       '''simple docstring'''


       if matrix_dimensions(UpperCamelCase__				)[1] != matrix_dimensions(UpperCamelCase__				)[0]:
              __lowercase      =    (
                  '''Unable to multiply these matrices, please check the dimensions.\n'''
                  F'Matrix A: {matrixa}\n'
                  F'Matrix B: {matrixa}'
              )
              raise Exception(UpperCamelCase__				)
       __lowercase      =    matrix_dimensions(UpperCamelCase__				)
       __lowercase      =    matrix_dimensions(UpperCamelCase__				)

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

       __lowercase      =    max(*UpperCamelCase__				,       *UpperCamelCase__				)
       __lowercase      =    int(math.pow(2				,       math.ceil(math.loga(UpperCamelCase__				)				)				)				)
       __lowercase      =    matrixa
       __lowercase      =    matrixa

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

       __lowercase      =    actual_strassen(UpperCamelCase__				,       UpperCamelCase__				)

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


if __name__ == "__main__":
   UpperCAmelCase__				     = [
       [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],
   ]
   UpperCAmelCase__				     = [[0, 2, 1, 1], [16, 2, 3, 3], [2, 2, 7, 7], [13, 11, 22, 4]]
   print(strassen(matrixa, matrixa))












import argparse


UpperCAmelCase__				     = "docs/source/_static/js/custom.js"







def 		_A(       UpperCamelCase__							:			Optional[int]				)    -> Optional[int]:
							'''simple docstring'''


							with open(UpperCamelCase__				,       encoding='''utf-8'''				,       newline='''\n'''				) as f:
														__lowercase      =    f.readlines()
							__lowercase      =    0

							# First let's put the right version
							while not lines[index].startswith('''const stableVersion ='''				):
														index += 1
							__lowercase      =    F'const stableVersion = "v{version}"\n'

							# Then update the dictionary
							while not lines[index].startswith('''const versionMapping = {'''				):
														index += 1

							# We go until the end
							while not lines[index].startswith('''}'''				):
														index += 1
							# We add the new version at the end
							lines[index - 1] += F'    "v{version}": "v{version}",\n'

							with open(UpperCamelCase__				,       '''w'''				,       encoding='''utf-8'''				,       newline='''\n'''				) as f:
														f.writelines(UpperCamelCase__				)


if __name__ == "__main__":
			UpperCAmelCase__				     = argparse.ArgumentParser()
			parser.add_argument("--version", help="Release version.")
			UpperCAmelCase__				     = parser.parse_args()
			update_custom_js(args.version)






