






'''simple docstring'''







from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


lowercase					:							Dict   =      logging.get_logger(__name__)

# General docstring
lowercase					:							str   =      "ResNetConfig"

# Base docstring
lowercase					:							Any   =      "microsoft/resnet-50"
lowercase					:							List[str]   =      [1, 2048, 7, 7]

# Image classification docstring
lowercase					:							Any   =      "microsoft/resnet-50"
lowercase					:							Optional[Any]   =      "tiger cat"

lowercase					:							int   =      [
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = 3					,     lowerCAmelCase_ = 1					,     lowerCAmelCase_ = "relu"						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	nn.Convad(
								    lowerCAmelCase_					,     lowerCAmelCase_					,     kernel_size=lowerCAmelCase_					,     stride=lowerCAmelCase_					,     padding=kernel_size // 2					,     bias=lowerCAmelCase_						)
								_snake_case     		=	nn.BatchNormad(lowerCAmelCase_						)
								_snake_case     		=	ACTaFN[activation] if activation is not None else nn.Identity()




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.convolution(lowerCAmelCase_						)
								_snake_case     		=	self.normalization(lowerCAmelCase_						)
								_snake_case     		=	self.activation(lowerCAmelCase_						)
								return hidden_state


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	ResNetConvLayer(
								    config.num_channels					,     config.embedding_size					,     kernel_size=7					,     stride=2					,     activation=config.hidden_act						)
								_snake_case     		=	nn.MaxPoolad(kernel_size=3					,     stride=2					,     padding=1						)
								_snake_case     		=	config.num_channels




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	pixel_values.shape[1]
								if num_channels != self.num_channels:
									raise ValueError(
									    'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'						)
								_snake_case     		=	self.embedder(lowerCAmelCase_						)
								_snake_case     		=	self.pooler(lowerCAmelCase_						)
								return embedding


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = 2						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	nn.Convad(lowerCAmelCase_					,     lowerCAmelCase_					,     kernel_size=1					,     stride=lowerCAmelCase_					,     bias=lowerCAmelCase_						)
								_snake_case     		=	nn.BatchNormad(lowerCAmelCase_						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.convolution(lowerCAmelCase_						)
								_snake_case     		=	self.normalization(lowerCAmelCase_						)
								return hidden_state


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = 1					,     lowerCAmelCase_ = "relu"						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	in_channels != out_channels or stride != 1
								_snake_case     		=	(
								    ResNetShortCut(lowerCAmelCase_					,     lowerCAmelCase_					,     stride=lowerCAmelCase_						) if should_apply_shortcut else nn.Identity()
								)
								_snake_case     		=	nn.Sequential(
								    ResNetConvLayer(lowerCAmelCase_					,     lowerCAmelCase_					,     stride=lowerCAmelCase_						)					,     ResNetConvLayer(lowerCAmelCase_					,     lowerCAmelCase_					,     activation=lowerCAmelCase_						)					,     )
								_snake_case     		=	ACTaFN[activation]




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	hidden_state
								_snake_case     		=	self.layer(lowerCAmelCase_						)
								_snake_case     		=	self.shortcut(lowerCAmelCase_						)
								hidden_state += residual
								_snake_case     		=	self.activation(lowerCAmelCase_						)
								return hidden_state


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = 1					,     lowerCAmelCase_ = "relu"					,     lowerCAmelCase_ = 4						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	in_channels != out_channels or stride != 1
								_snake_case     		=	out_channels // reduction
								_snake_case     		=	(
								    ResNetShortCut(lowerCAmelCase_					,     lowerCAmelCase_					,     stride=lowerCAmelCase_						) if should_apply_shortcut else nn.Identity()
								)
								_snake_case     		=	nn.Sequential(
								    ResNetConvLayer(lowerCAmelCase_					,     lowerCAmelCase_					,     kernel_size=1						)					,     ResNetConvLayer(lowerCAmelCase_					,     lowerCAmelCase_					,     stride=lowerCAmelCase_						)					,     ResNetConvLayer(lowerCAmelCase_					,     lowerCAmelCase_					,     kernel_size=1					,     activation=lowerCAmelCase_						)					,     )
								_snake_case     		=	ACTaFN[activation]




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	hidden_state
								_snake_case     		=	self.layer(lowerCAmelCase_						)
								_snake_case     		=	self.shortcut(lowerCAmelCase_						)
								hidden_state += residual
								_snake_case     		=	self.activation(lowerCAmelCase_						)
								return hidden_state


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_ = 2					,     lowerCAmelCase_ = 2					,     ):





								"""simple docstring"""






								super().__init__()

								_snake_case     		=	ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

								_snake_case     		=	nn.Sequential(
								    # downsampling is done in the first layer with stride of 2
								    layer(lowerCAmelCase_					,     lowerCAmelCase_					,     stride=lowerCAmelCase_					,     activation=config.hidden_act						)					,     *[layer(lowerCAmelCase_					,     lowerCAmelCase_					,     activation=config.hidden_act						) for _ in range(depth - 1						)]					,     )




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	input
								for layer in self.layers:
									_snake_case     		=	layer(lowerCAmelCase_						)
								return hidden_state


class 		__UpperCAmelCase   (      nn.Module		):


							def __init__( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								super().__init__()
								_snake_case     		=	nn.ModuleList([]						)
								# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
								self.stages.append(
								    ResNetStage(
								        lowerCAmelCase_					,     config.embedding_size					,     config.hidden_sizes[0]					,     stride=2 if config.downsample_in_first_stage else 1					,     depth=config.depths[0]					,     )						)
								_snake_case     		=	zip(config.hidden_sizes					,     config.hidden_sizes[1:]						)
								for (in_channels, out_channels), depth in zip(lowerCAmelCase_					,     config.depths[1:]						):
									self.stages.append(ResNetStage(lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     depth=lowerCAmelCase_						)						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = False					,     lowerCAmelCase_ = True						):





								"""simple docstring"""






								_snake_case     		=	() if output_hidden_states else None

								for stage_module in self.stages:
									if output_hidden_states:
										_snake_case     		=	hidden_states + (hidden_state,)

									_snake_case     		=	stage_module(lowerCAmelCase_						)

								if output_hidden_states:
									_snake_case     		=	hidden_states + (hidden_state,)

								if not return_dict:
									return tuple(v for v in [hidden_state, hidden_states] if v is not None						)

								return BaseModelOutputWithNoAttention(
								    last_hidden_state=lowerCAmelCase_					,     hidden_states=lowerCAmelCase_					,     )


class 		__UpperCAmelCase   (      _lowerCamelCase		):
							__lowercase   	= ResNetConfig
							__lowercase   	= """resnet"""
							__lowercase   	= """pixel_values"""
							__lowercase   	= True


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								if isinstance(lowerCAmelCase_					,     nn.Convad						):
									nn.init.kaiming_normal_(module.weight					,     mode='fan_out'					,     nonlinearity='relu'						)
								elif isinstance(lowerCAmelCase_					,     (nn.BatchNormad, nn.GroupNorm)						):
									nn.init.constant_(module.weight					,     1						)
									nn.init.constant_(module.bias					,     0						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_=False						):





								"""simple docstring"""






								if isinstance(lowerCAmelCase_					,     lowerCAmelCase_						):
									_snake_case     		=	value
lowercase					:							Optional[int]   =      r"\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n"

lowercase					:							List[Any]   =      r"\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"


@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""		,     _lowerCamelCase		,     )
class 		__UpperCAmelCase   (      _lowerCamelCase		):


							def __init__( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								super().__init__(lowerCAmelCase_						)
								_snake_case     		=	config
								_snake_case     		=	ResNetEmbeddings(lowerCAmelCase_						)
								_snake_case     		=	ResNetEncoder(lowerCAmelCase_						)
								_snake_case     		=	nn.AdaptiveAvgPoolad((1, 1)						)
								# Initialize weights and apply final processing
								self.post_init()




							@add_start_docstrings_to_model_forward(lowerCAmelCase_						)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC					,     output_type=lowerCAmelCase_					,     config_class=_CONFIG_FOR_DOC					,     modality='vision'					,     expected_output=_EXPECTED_OUTPUT_SHAPE					,     )
							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								_snake_case     		=	return_dict if return_dict is not None else self.config.use_return_dict

								_snake_case     		=	self.embedder(lowerCAmelCase_						)

								_snake_case     		=	self.encoder(
								    lowerCAmelCase_					,     output_hidden_states=lowerCAmelCase_					,     return_dict=lowerCAmelCase_						)

								_snake_case     		=	encoder_outputs[0]

								_snake_case     		=	self.pooler(lowerCAmelCase_						)

								if not return_dict:
									return (last_hidden_state, pooled_output) + encoder_outputs[1:]

								return BaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=lowerCAmelCase_					,     pooler_output=lowerCAmelCase_					,     hidden_states=encoder_outputs.hidden_states					,     )


@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """		,     _lowerCamelCase		,     )
class 		__UpperCAmelCase   (      _lowerCamelCase		):


							def __init__( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								super().__init__(lowerCAmelCase_						)
								_snake_case     		=	config.num_labels
								_snake_case     		=	ResNetModel(lowerCAmelCase_						)
								# classification head
								_snake_case     		=	nn.Sequential(
								    nn.Flatten()					,     nn.Linear(config.hidden_sizes[-1]					,     config.num_labels						) if config.num_labels > 0 else nn.Identity()					,     )
								# initialize weights and apply final processing
								self.post_init()




							@add_start_docstrings_to_model_forward(lowerCAmelCase_						)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT					,     output_type=lowerCAmelCase_					,     config_class=_CONFIG_FOR_DOC					,     expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT					,     )
							def 				lowerCamelCase       ( self					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None					,     ):





								"""simple docstring"""






								_snake_case     		=	return_dict if return_dict is not None else self.config.use_return_dict

								_snake_case     		=	self.resnet(lowerCAmelCase_					,     output_hidden_states=lowerCAmelCase_					,     return_dict=lowerCAmelCase_						)

								_snake_case     		=	outputs.pooler_output if return_dict else outputs[1]

								_snake_case     		=	self.classifier(lowerCAmelCase_						)

								_snake_case     		=	None

								if labels is not None:
									if self.config.problem_type is None:
										if self.num_labels == 1:
											_snake_case     		=	'regression'
										elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
											_snake_case     		=	'single_label_classification'
										else:
											_snake_case     		=	'multi_label_classification'
									if self.config.problem_type == "regression":
										_snake_case     		=	MSELoss()
										if self.num_labels == 1:
											_snake_case     		=	loss_fct(logits.squeeze()					,     labels.squeeze()						)
										else:
											_snake_case     		=	loss_fct(lowerCAmelCase_					,     lowerCAmelCase_						)
									elif self.config.problem_type == "single_label_classification":
										_snake_case     		=	CrossEntropyLoss()
										_snake_case     		=	loss_fct(logits.view(-1					,     self.num_labels						)					,     labels.view(-1						)						)
									elif self.config.problem_type == "multi_label_classification":
										_snake_case     		=	BCEWithLogitsLoss()
										_snake_case     		=	loss_fct(lowerCAmelCase_					,     lowerCAmelCase_						)

								if not return_dict:
									_snake_case     		=	(logits,) + outputs[2:]
									return (loss,) + output if loss is not None else output

								return ImageClassifierOutputWithNoAttention(loss=lowerCAmelCase_					,     logits=lowerCAmelCase_					,     hidden_states=outputs.hidden_states						)


@add_start_docstrings(
    """
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    """		,     _lowerCamelCase		,     )
class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		):


							def __init__( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								super().__init__(lowerCAmelCase_						)
								super()._init_backbone(lowerCAmelCase_						)

								_snake_case     		=	[config.embedding_size] + config.hidden_sizes
								_snake_case     		=	ResNetEmbeddings(lowerCAmelCase_						)
								_snake_case     		=	ResNetEncoder(lowerCAmelCase_						)

								# initialize weights and apply final processing
								self.post_init()




							@add_start_docstrings_to_model_forward(lowerCAmelCase_						)
							@replace_return_docstrings(output_type=lowerCAmelCase_					,     config_class=_CONFIG_FOR_DOC						)
							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	return_dict if return_dict is not None else self.config.use_return_dict
								_snake_case     		=	(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)

								_snake_case     		=	self.embedder(lowerCAmelCase_						)

								_snake_case     		=	self.encoder(lowerCAmelCase_					,     output_hidden_states=lowerCAmelCase_					,     return_dict=lowerCAmelCase_						)

								_snake_case     		=	outputs.hidden_states

								_snake_case     		=	()
								for idx, stage in enumerate(self.stage_names						):
									if stage in self.out_features:
										feature_maps += (hidden_states[idx],)

								if not return_dict:
									_snake_case     		=	(feature_maps,)
									if output_hidden_states:
										output += (outputs.hidden_states,)
									return output

								return BackboneOutput(
								    feature_maps=lowerCAmelCase_					,     hidden_states=outputs.hidden_states if output_hidden_states else None					,     attentions=lowerCAmelCase_					,     )



'''simple docstring'''







from __future__ import annotations

import math







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			list:
	if len(__A			) != 2 or len(a[0]			) != 2 or len(__A			) != 2 or len(b[0]			) != 2:
		raise Exception('Matrices are not 2x2'			)
	_snake_case     		=	[
	    [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        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			Dict:
	return [
	    [matrix_a[row][col] + matrix_b[row][col] for col in range(len(matrix_a[row]			)			)]
	    for row in range(len(__A			)			)
	]







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			Dict:
	return [
	    [matrix_a[row][col] - matrix_b[row][col] for col in range(len(matrix_a[row]			)			)]
	    for row in range(len(__A			)			)
	]







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			tuple[list, list, list, list]:
	if len(__A			) % 2 != 0 or len(a[0]			) % 2 != 0:
		raise Exception('Odd matrices are not supported!'			)

	_snake_case     		=	len(__A			)
	_snake_case     		=	matrix_length // 2

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

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

	return top_left, top_right, bot_left, bot_right







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			tuple[int, int]:
	return len(__A			), len(matrix[0]			)







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			None:
	print('\n'.join(str(__A			) for line in matrix			)			)







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			list:
	if matrix_dimensions(__A			) == (2, 2):
		return default_matrix_multiplication(__A    ,       __A			)

	_snake_case		,				_snake_case		,				_snake_case		,				_snake_case     		=	split_matrix(__A			)
	_snake_case		,				_snake_case		,				_snake_case		,				_snake_case     		=	split_matrix(__A			)

	_snake_case     		=	actual_strassen(__A    ,       matrix_subtraction(__A    ,       __A			)			)
	_snake_case     		=	actual_strassen(matrix_addition(__A    ,       __A			)    ,       __A			)
	_snake_case     		=	actual_strassen(matrix_addition(__A    ,       __A			)    ,       __A			)
	_snake_case     		=	actual_strassen(__A    ,       matrix_subtraction(__A    ,       __A			)			)
	_snake_case     		=	actual_strassen(matrix_addition(__A    ,       __A			)    ,       matrix_addition(__A    ,       __A			)			)
	_snake_case     		=	actual_strassen(matrix_subtraction(__A    ,       __A			)    ,       matrix_addition(__A    ,       __A			)			)
	_snake_case     		=	actual_strassen(matrix_subtraction(__A    ,       __A			)    ,       matrix_addition(__A    ,       __A			)			)

	_snake_case     		=	matrix_addition(matrix_subtraction(matrix_addition(__A    ,       __A			)    ,       __A			)    ,       __A			)
	_snake_case     		=	matrix_addition(__A    ,       __A			)
	_snake_case     		=	matrix_addition(__A    ,       __A			)
	_snake_case     		=	matrix_subtraction(matrix_subtraction(matrix_addition(__A    ,       __A			)    ,       __A			)    ,       __A			)

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

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

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

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

