

'''simple docstring'''




from __future__ import annotations

import math




def 						UpperCamelCase	(			a		,						a			)				->     list:






     '''simple docstring'''
     if len(a			) != 2 or len(a[0]			) != 2 or len(a			) != 2 or len(b[0]			) != 2:
          raise Exception('''Matrices are not 2x2'''			)
     __magic_name__						       =    [
         [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 						UpperCamelCase	(			a		,						a			)				->     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(a			)			)
     ]




def 						UpperCamelCase	(			a		,						a			)				->     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(a			)			)
     ]




def 						UpperCamelCase	(			a			)				->     tuple[list, list, list, list]:






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

     __magic_name__						       =    len(a			)
     __magic_name__						       =    matrix_length // 2

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

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

     return top_left, top_right, bot_left, bot_right




def 						UpperCamelCase	(			a			)				->     tuple[int, int]:






     '''simple docstring'''
     return len(a			), len(matrix[0]			)




def 						UpperCamelCase	(			a			)				->     None:






     '''simple docstring'''
     print('''\n'''.join(str(a			) for line in matrix			)			)




def 						UpperCamelCase	(			a		,						a			)				->     list:






     '''simple docstring'''
     if matrix_dimensions(a			) == (2, 2):
          return default_matrix_multiplication(a		,						a			)

     __magic_name__       ,  __magic_name__       ,  __magic_name__       ,  __magic_name__						       =    split_matrix(a			)
     __magic_name__       ,  __magic_name__       ,  __magic_name__       ,  __magic_name__						       =    split_matrix(a			)

     __magic_name__						       =    actual_strassen(a		,						matrix_subtraction(a		,						a			)			)
     __magic_name__						       =    actual_strassen(matrix_addition(a		,						a			)		,						a			)
     __magic_name__						       =    actual_strassen(matrix_addition(a		,						a			)		,						a			)
     __magic_name__						       =    actual_strassen(a		,						matrix_subtraction(a		,						a			)			)
     __magic_name__						       =    actual_strassen(matrix_addition(a		,						a			)		,						matrix_addition(a		,						a			)			)
     __magic_name__						       =    actual_strassen(matrix_subtraction(a		,						a			)		,						matrix_addition(a		,						a			)			)
     __magic_name__						       =    actual_strassen(matrix_subtraction(a		,						a			)		,						matrix_addition(a		,						a			)			)

     __magic_name__						       =    matrix_addition(matrix_subtraction(matrix_addition(a		,						a			)		,						a			)		,						a			)
     __magic_name__						       =    matrix_addition(a		,						a			)
     __magic_name__						       =    matrix_addition(a		,						a			)
     __magic_name__						       =    matrix_subtraction(matrix_subtraction(matrix_addition(a		,						a			)		,						a			)		,						a			)

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




def 						UpperCamelCase	(			a		,						a			)				->     list:






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

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

     __magic_name__						       =    max(*a		,						*a			)
     __magic_name__						       =    int(math.pow(2		,						math.ceil(math.loga(a			)			)			)			)
     __magic_name__						       =    matrixa
     __magic_name__						       =    matrixa

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

     __magic_name__						       =    actual_strassen(a		,						a			)

     # Removing the additional zeros
     for i in range(0		,						a			):
          if i < dimensiona[0]:
               for _ in range(dimensiona[1]		,						a			):
                    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))









'''simple docstring'''




from __future__ import annotations

from fractions import Fraction




def 						UpperCamelCase	(			a		,						a			)				->     bool:






     '''simple docstring'''
     return (
         num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
     )




def 						UpperCamelCase	(			a			)				->     list[str]:






     '''simple docstring'''
     __magic_name__						       =    []
     __magic_name__						       =    11
     __magic_name__						       =    int('''1''' + '''0''' * digit_len			)
     for num in range(a		,						a			):
          while den <= 99:
               if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                    if is_digit_cancelling(a		,						a			):
                         solutions.append(F'''{num}/{den}'''			)
               den += 1
          num += 1
          __magic_name__						       =    10
     return solutions




def 						UpperCamelCase	(			a = 2			)				->     int:






     '''simple docstring'''
     __magic_name__						       =    1.0
     for fraction in fraction_list(a			):
          __magic_name__						       =    Fraction(a			)
          result *= frac.denominator / frac.numerator
     return int(a			)


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






