"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TFFunnelBaseModel,
	    TFFunnelForMaskedLM,
	    TFFunnelForMultipleChoice,
	    TFFunnelForPreTraining,
	    TFFunnelForQuestionAnswering,
	    TFFunnelForSequenceClassification,
	    TFFunnelForTokenClassification,
	    TFFunnelModel,
	)






class   __UpperCAmelCase		:

				def __init__( self      ,					_lowerCamelCase      ,					_lowerCamelCase=13      ,					_lowerCamelCase=7      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=99      ,					_lowerCamelCase=[1, 1, 2]      ,					_lowerCamelCase=1      ,					_lowerCamelCase=32      ,					_lowerCamelCase=4      ,					_lowerCamelCase=8      ,					_lowerCamelCase=37      ,					_lowerCamelCase="gelu_new"      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=0.0      ,					_lowerCamelCase=512      ,					_lowerCamelCase=3      ,					_lowerCamelCase=0.0_2      ,					_lowerCamelCase=3      ,					_lowerCamelCase=4      ,					_lowerCamelCase=None      ,					_lowerCamelCase=False      ,					):
										lowerCamelCase__   =parent
										lowerCamelCase__   =batch_size
										lowerCamelCase__   =seq_length
										lowerCamelCase__   =is_training
										lowerCamelCase__   =use_input_mask
										lowerCamelCase__   =use_token_type_ids
										lowerCamelCase__   =use_labels
										lowerCamelCase__   =vocab_size
										lowerCamelCase__   =block_sizes
										lowerCamelCase__   =num_decoder_layers
										lowerCamelCase__   =d_model
										lowerCamelCase__   =n_head
										lowerCamelCase__   =d_head
										lowerCamelCase__   =d_inner
										lowerCamelCase__   =hidden_act
										lowerCamelCase__   =hidden_dropout
										lowerCamelCase__   =attention_dropout
										lowerCamelCase__   =activation_dropout
										lowerCamelCase__   =max_position_embeddings
										lowerCamelCase__   =type_vocab_size
										lowerCamelCase__   =2
										lowerCamelCase__   =num_labels
										lowerCamelCase__   =num_choices
										lowerCamelCase__   =scope
										lowerCamelCase__   =initializer_std

										# Used in the tests to check the size of the first attention layer
										lowerCamelCase__   =n_head
										# Used in the tests to check the size of the first hidden state
										lowerCamelCase__   =self.d_model
										# Used in the tests to check the number of output hidden states/attentions
										lowerCamelCase__   =sum(self.block_sizes ) + (0 if base else self.num_decoder_layers)
										# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
										# the last hidden state of the first block (which is the first hidden state of the decoder).
										if not base:
																lowerCamelCase__   =self.num_hidden_layers + 2

				def 						_a      ( self ):
										lowerCamelCase__   =ids_tensor([self.batch_size, self.seq_length]      ,					self.vocab_size )

										lowerCamelCase__   =None
										if self.use_input_mask:
																lowerCamelCase__   =random_attention_mask([self.batch_size, self.seq_length] )

										lowerCamelCase__   =None
										if self.use_token_type_ids:
																lowerCamelCase__   =ids_tensor([self.batch_size, self.seq_length]      ,					self.type_vocab_size )

										lowerCamelCase__   =None
										lowerCamelCase__   =None
										lowerCamelCase__   =None
										if self.use_labels:
																lowerCamelCase__   =ids_tensor([self.batch_size]      ,					self.type_sequence_label_size )
																lowerCamelCase__   =ids_tensor([self.batch_size, self.seq_length]      ,					self.num_labels )
																lowerCamelCase__   =ids_tensor([self.batch_size]      ,					self.num_choices )

										lowerCamelCase__   =FunnelConfig(
										    vocab_size=self.vocab_size      ,					block_sizes=self.block_sizes      ,					num_decoder_layers=self.num_decoder_layers      ,					d_model=self.d_model      ,					n_head=self.n_head      ,					d_head=self.d_head      ,					d_inner=self.d_inner      ,					hidden_act=self.hidden_act      ,					hidden_dropout=self.hidden_dropout      ,					attention_dropout=self.attention_dropout      ,					activation_dropout=self.activation_dropout      ,					max_position_embeddings=self.max_position_embeddings      ,					type_vocab_size=self.type_vocab_size      ,					initializer_std=self.initializer_std      ,					)

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										)

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =TFFunnelModel(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )

										lowerCamelCase__   =[input_ids, input_mask]
										lowerCamelCase__   =model(_lowerCamelCase )

										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.d_model) )

										lowerCamelCase__   =False
										lowerCamelCase__   =TFFunnelModel(config=_lowerCamelCase )
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.d_model) )

										lowerCamelCase__   =False
										lowerCamelCase__   =TFFunnelModel(config=_lowerCamelCase )
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, self.seq_length, self.d_model) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =TFFunnelBaseModel(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )

										lowerCamelCase__   =[input_ids, input_mask]
										lowerCamelCase__   =model(_lowerCamelCase )

										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, 2, self.d_model) )

										lowerCamelCase__   =False
										lowerCamelCase__   =TFFunnelBaseModel(config=_lowerCamelCase )
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, 3, self.d_model) )

										lowerCamelCase__   =False
										lowerCamelCase__   =TFFunnelBaseModel(config=_lowerCamelCase )
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.last_hidden_state.shape      ,					(self.batch_size, 2, self.d_model) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =TFFunnelForPreTraining(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.seq_length) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =TFFunnelForMaskedLM(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.seq_length, self.vocab_size) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =self.num_labels
										lowerCamelCase__   =TFFunnelForSequenceClassification(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.num_labels) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =self.num_choices
										lowerCamelCase__   =TFFunnelForMultipleChoice(config=_lowerCamelCase )
										lowerCamelCase__   =tf.tile(tf.expand_dims(_lowerCamelCase      ,					1 )      ,					(1, self.num_choices, 1) )
										lowerCamelCase__   =tf.tile(tf.expand_dims(_lowerCamelCase      ,					1 )      ,					(1, self.num_choices, 1) )
										lowerCamelCase__   =tf.tile(tf.expand_dims(_lowerCamelCase      ,					1 )      ,					(1, self.num_choices, 1) )
										lowerCamelCase__   ={
										    "input_ids": multiple_choice_inputs_ids,
										    "attention_mask": multiple_choice_input_mask,
										    "token_type_ids": multiple_choice_token_type_ids,
										}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.num_choices) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =self.num_labels
										lowerCamelCase__   =TFFunnelForTokenClassification(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.seq_length, self.num_labels) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					):
										lowerCamelCase__   =TFFunnelForQuestionAnswering(config=_lowerCamelCase )
										lowerCamelCase__   ={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCamelCase__   =model(_lowerCamelCase )
										self.parent.assertEqual(result.start_logits.shape      ,					(self.batch_size, self.seq_length) )
										self.parent.assertEqual(result.end_logits.shape      ,					(self.batch_size, self.seq_length) )






				def 						_a      ( self ):
										lowerCamelCase__   =self.prepare_config_and_inputs()
										(
										    (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , (
										    lowerCamelCase__
										)   , 
										)   =config_and_inputs
										lowerCamelCase__   ={"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
										return config, inputs_dict






@require_tf
class   __UpperCAmelCase		(      __lowerCAmelCase , __lowerCAmelCase , unittest.TestCase      ):
				A__ :  List[str]    				=			(
				    (
				        TFFunnelModel,
				        TFFunnelForMaskedLM,
				        TFFunnelForPreTraining,
				        TFFunnelForQuestionAnswering,
				        TFFunnelForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				A__ :  Any    				=			(
				    {
				        '''feature-extraction''': (TFFunnelBaseModel, TFFunnelModel),
				        '''fill-mask''': TFFunnelForMaskedLM,
				        '''question-answering''': TFFunnelForQuestionAnswering,
				        '''text-classification''': TFFunnelForSequenceClassification,
				        '''token-classification''': TFFunnelForTokenClassification,
				        '''zero-shot''': TFFunnelForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				A__ :  Optional[Any]    				=			False
				A__ :  Optional[Any]    				=			False

				def 						_a      ( self ):
										lowerCamelCase__   =TFFunnelModelTester(self )
										lowerCamelCase__   =ConfigTester(self      ,					config_class=_lowerCamelCase )

				def 						_a      ( self ):
										self.config_tester.run_common_tests()

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase )






				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase )






@require_tf
class   __UpperCAmelCase		(      __lowerCAmelCase , unittest.TestCase      ):
				A__ :  Union[str, Any]    				=			(
				    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
				)
				A__ :  List[str]    				=			False
				A__ :  Dict    				=			False

				def 						_a      ( self ):
										lowerCamelCase__   =TFFunnelModelTester(self      ,					base=_lowerCamelCase )
										lowerCamelCase__   =ConfigTester(self      ,					config_class=_lowerCamelCase )

				def 						_a      ( self ):
										self.config_tester.run_common_tests()

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_base_model(*_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase )






				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase )



"""simple docstring"""


from __future__ import annotations

import math





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   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"							)
						lowerCamelCase__   =[
						    [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_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   Dict:




						'''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      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   List[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      lowerCamelCase_					(   __lowerCAmelCase							)				->   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!"							)

						lowerCamelCase__   =len(__lowerCAmelCase							)
						lowerCamelCase__   =matrix_length // 2

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

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

						return top_left, top_right, bot_left, bot_right





def      lowerCamelCase_					(   __lowerCAmelCase							)				->   tuple[int, int]:




						'''simple docstring'''



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





def      lowerCamelCase_					(   __lowerCAmelCase							)				->   None:




						'''simple docstring'''



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





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   list:




						'''simple docstring'''



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

						lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   =split_matrix(__lowerCAmelCase							)
						lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   =split_matrix(__lowerCAmelCase							)

						lowerCamelCase__   =actual_strassen(__lowerCAmelCase  ,       matrix_subtraction(__lowerCAmelCase  ,       __lowerCAmelCase							)							)
						lowerCamelCase__   =actual_strassen(matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)
						lowerCamelCase__   =actual_strassen(matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)
						lowerCamelCase__   =actual_strassen(__lowerCAmelCase  ,       matrix_subtraction(__lowerCAmelCase  ,       __lowerCAmelCase							)							)
						lowerCamelCase__   =actual_strassen(matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)							)
						lowerCamelCase__   =actual_strassen(matrix_subtraction(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)							)
						lowerCamelCase__   =actual_strassen(matrix_subtraction(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)							)

						lowerCamelCase__   =matrix_addition(matrix_subtraction(matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)
						lowerCamelCase__   =matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)
						lowerCamelCase__   =matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)
						lowerCamelCase__   =matrix_subtraction(matrix_subtraction(matrix_addition(__lowerCAmelCase  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)  ,       __lowerCAmelCase							)

						# construct the new matrix from our 4 quadrants
						lowerCamelCase__   =[]
						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      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase							)				->   list:




						'''simple docstring'''



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

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

						lowerCamelCase__   =max(*__lowerCAmelCase  ,       *__lowerCAmelCase							)
						lowerCamelCase__   =int(math.pow(2  ,       math.ceil(math.loga(__lowerCAmelCase							)							)							)							)
						lowerCamelCase__   =matrixa
						lowerCamelCase__   =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							)

						lowerCamelCase__   =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				=[
	    [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				=[[0, 2, 1, 1], [16, 2, 3, 3], [2, 2, 7, 7], [13, 11, 22, 4]]
	print(strassen(matrixa, matrixa))


