


'''simple docstring'''






from __future__ import annotations

import math






def 	_A				(lowerCAmelCase__  :list				,						lowerCAmelCase__  :list		)   ->  list:




     '''simple docstring'''



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






def 	_A				(lowerCAmelCase__  :list				,						lowerCAmelCase__  :list		)   ->  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(lowerCAmelCase__		)		)
     ]






def 	_A				(lowerCAmelCase__  :list		)   ->  tuple[list, list, list, list]:




     '''simple docstring'''



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

     _a			      =							len(lowerCAmelCase__		)
     _a			      =							matrix_length // 2

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

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

     return top_left, top_right, bot_left, bot_right






def 	_A				(lowerCAmelCase__  :list		)   ->  tuple[int, int]:




     '''simple docstring'''



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






def 	_A				(lowerCAmelCase__  :list		)   ->  None:




     '''simple docstring'''



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






def 	_A				(lowerCAmelCase__  :list				,						lowerCAmelCase__  :list		)   ->  list:




     '''simple docstring'''



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

     _a      ,   _a      ,   _a      ,   _a			      =							split_matrix(lowerCAmelCase__		)
     _a      ,   _a      ,   _a      ,   _a			      =							split_matrix(lowerCAmelCase__		)

     _a			      =							actual_strassen(lowerCAmelCase__				,						matrix_subtraction(lowerCAmelCase__				,						lowerCAmelCase__		)		)
     _a			      =							actual_strassen(matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)
     _a			      =							actual_strassen(matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)
     _a			      =							actual_strassen(lowerCAmelCase__				,						matrix_subtraction(lowerCAmelCase__				,						lowerCAmelCase__		)		)
     _a			      =							actual_strassen(matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)				,						matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)		)
     _a			      =							actual_strassen(matrix_subtraction(lowerCAmelCase__				,						lowerCAmelCase__		)				,						matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)		)
     _a			      =							actual_strassen(matrix_subtraction(lowerCAmelCase__				,						lowerCAmelCase__		)				,						matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)		)

     _a			      =							matrix_addition(matrix_subtraction(matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)
     _a			      =							matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)
     _a			      =							matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)
     _a			      =							matrix_subtraction(matrix_subtraction(matrix_addition(lowerCAmelCase__				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)				,						lowerCAmelCase__		)

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






def 	_A				(lowerCAmelCase__  :list				,						lowerCAmelCase__  :list		)   ->  list:




     '''simple docstring'''



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

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

     _a			      =							max(*lowerCAmelCase__				,						*lowerCAmelCase__		)
     _a			      =							int(math.pow(2				,						math.ceil(math.loga(lowerCAmelCase__		)		)		)		)
     _a			      =							matrixa
     _a			      =							matrixa

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

     _a			      =							actual_strassen(lowerCAmelCase__				,						lowerCAmelCase__		)

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


if __name__ == "__main__":
 a_					:    List[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],
 ]
 a_					:    Union[str, Any]          =    [[0, 2, 1, 1], [1_6, 2, 3, 3], [2, 2, 7, 7], [1_3, 1_1, 2_2, 4]]
 print(strassen(matrixa, matrixa))





'''simple docstring'''






import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()






def 	_A				(lowerCAmelCase__  :str				,						lowerCAmelCase__  :int				,						lowerCAmelCase__  :Any		)   ->  str:




     '''simple docstring'''



     _a			      =							BertConfig.from_json_file(lowerCAmelCase__		)
     print(f'Building PyTorch model from configuration: {config}'		)
     _a			      =							BertForPreTraining(lowerCAmelCase__		)

     # Load weights from tf checkpoint
     load_tf_weights_in_bert(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)

     # Save pytorch-model
     print(f'Save PyTorch model to {pytorch_dump_path}'		)
     torch.save(model.state_dict()				,						lowerCAmelCase__		)


if __name__ == "__main__":
 a_					:    Optional[int]          =    argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
 )
 parser.add_argument(
     "--bert_config_file",
     default=None,
     type=str,
     required=True,
     help=(
         "The config json file corresponding to the pre-trained BERT model. \n"
         "This specifies the model architecture."
     ),
 )
 parser.add_argument(
     "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
 )
 a_					:    Optional[int]          =    parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)

