





'''simple docstring'''




from __future__ import annotations

import math



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""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"""	)
		SCREAMING_SNAKE_CASE :				str		=			[
		    [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_			,			lowerCamelCase_	):


		"""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_			,			lowerCamelCase_	):


		"""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_	):


		"""simple docstring"""



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

		SCREAMING_SNAKE_CASE :				Dict		=			len(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				List[Any]		=			matrix_length // 2

		SCREAMING_SNAKE_CASE :				Tuple		=			[[a[i][j] for j in range(lowerCamelCase_			,			lowerCamelCase_	)] for i in range(lowerCamelCase_	)]
		SCREAMING_SNAKE_CASE :				str		=			[
		    [a[i][j] for j in range(lowerCamelCase_			,			lowerCamelCase_	)] for i in range(lowerCamelCase_			,			lowerCamelCase_	)
		]

		SCREAMING_SNAKE_CASE :				str		=			[[a[i][j] for j in range(lowerCamelCase_	)] for i in range(lowerCamelCase_	)]
		SCREAMING_SNAKE_CASE :				List[Any]		=			[[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_	):


		"""simple docstring"""



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



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



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



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



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

		SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				Any		=			split_matrix(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE,							SCREAMING_SNAKE_CASE :				Optional[int]		=			split_matrix(lowerCamelCase_	)

		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			actual_strassen(lowerCamelCase_			,			matrix_subtraction(lowerCamelCase_			,			lowerCamelCase_	)	)
		SCREAMING_SNAKE_CASE :				Any		=			actual_strassen(matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			actual_strassen(matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Dict		=			actual_strassen(lowerCamelCase_			,			matrix_subtraction(lowerCamelCase_			,			lowerCamelCase_	)	)
		SCREAMING_SNAKE_CASE :				int		=			actual_strassen(matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)			,			matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)	)
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			actual_strassen(matrix_subtraction(lowerCamelCase_			,			lowerCamelCase_	)			,			matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)	)
		SCREAMING_SNAKE_CASE :				Tuple		=			actual_strassen(matrix_subtraction(lowerCamelCase_			,			lowerCamelCase_	)			,			matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)	)

		SCREAMING_SNAKE_CASE :				Optional[int]		=			matrix_addition(matrix_subtraction(matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)			,			lowerCamelCase_	)			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Any		=			matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				int		=			matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Dict		=			matrix_subtraction(matrix_subtraction(matrix_addition(lowerCamelCase_			,			lowerCamelCase_	)			,			lowerCamelCase_	)			,			lowerCamelCase_	)

		# construct the new matrix from our 4 quadrants
		SCREAMING_SNAKE_CASE :				int		=			[]
		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_			,			lowerCamelCase_	):


		"""simple docstring"""



		if matrix_dimensions(lowerCamelCase_	)[1] != matrix_dimensions(lowerCamelCase_	)[0]:
				SCREAMING_SNAKE_CASE :				Optional[int]		=			(
				    """Unable to multiply these matrices, please check the dimensions.\n"""
				    f'''Matrix A: {matrixa}\n'''
				    f'''Matrix B: {matrixa}'''
				)
				raise Exception(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Dict		=			matrix_dimensions(lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			matrix_dimensions(lowerCamelCase_	)

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

		SCREAMING_SNAKE_CASE :				Optional[Any]		=			max(*lowerCamelCase_			,			*lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Tuple		=			int(math.pow(2			,			math.ceil(math.loga(lowerCamelCase_	)	)	)	)
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			matrixa
		SCREAMING_SNAKE_CASE :				Dict		=			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	)

		SCREAMING_SNAKE_CASE :				str		=			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__":
							__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))










'''simple docstring'''




__UpperCAmelCase            =       """0.18.2"""

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
							if not is_onnx_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_onnx_objects import *  # noqa F403
else:
							from .pipelines import OnnxRuntimeModel

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_pt_objects import *  # noqa F403
else:
							from .models import (
							    AutoencoderKL,
							    ControlNetModel,
							    ModelMixin,
							    PriorTransformer,
							    TaFilmDecoder,
							    TransformeraDModel,
							    UNetaDModel,
							    UNetaDConditionModel,
							    UNetaDModel,
							    UNetaDConditionModel,
							    VQModel,
							)
							from .optimization import (
							    get_constant_schedule,
							    get_constant_schedule_with_warmup,
							    get_cosine_schedule_with_warmup,
							    get_cosine_with_hard_restarts_schedule_with_warmup,
							    get_linear_schedule_with_warmup,
							    get_polynomial_decay_schedule_with_warmup,
							    get_scheduler,
							)
							from .pipelines import (
							    AudioPipelineOutput,
							    ConsistencyModelPipeline,
							    DanceDiffusionPipeline,
							    DDIMPipeline,
							    DDPMPipeline,
							    DiffusionPipeline,
							    DiTPipeline,
							    ImagePipelineOutput,
							    KarrasVePipeline,
							    LDMPipeline,
							    LDMSuperResolutionPipeline,
							    PNDMPipeline,
							    RePaintPipeline,
							    ScoreSdeVePipeline,
							)
							from .schedulers import (
							    CMStochasticIterativeScheduler,
							    DDIMInverseScheduler,
							    DDIMParallelScheduler,
							    DDIMScheduler,
							    DDPMParallelScheduler,
							    DDPMScheduler,
							    DEISMultistepScheduler,
							    DPMSolverMultistepInverseScheduler,
							    DPMSolverMultistepScheduler,
							    DPMSolverSinglestepScheduler,
							    EulerAncestralDiscreteScheduler,
							    EulerDiscreteScheduler,
							    HeunDiscreteScheduler,
							    IPNDMScheduler,
							    KarrasVeScheduler,
							    KDPMaAncestralDiscreteScheduler,
							    KDPMaDiscreteScheduler,
							    PNDMScheduler,
							    RePaintScheduler,
							    SchedulerMixin,
							    ScoreSdeVeScheduler,
							    UnCLIPScheduler,
							    UniPCMultistepScheduler,
							    VQDiffusionScheduler,
							)
							from .training_utils import EMAModel

try:
							if not (is_torch_available() and is_scipy_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
							from .schedulers import LMSDiscreteScheduler

try:
							if not (is_torch_available() and is_torchsde_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
							from .schedulers import DPMSolverSDEScheduler

try:
							if not (is_torch_available() and is_transformers_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
							from .pipelines import (
							    AltDiffusionImgaImgPipeline,
							    AltDiffusionPipeline,
							    AudioLDMPipeline,
							    CycleDiffusionPipeline,
							    IFImgaImgPipeline,
							    IFImgaImgSuperResolutionPipeline,
							    IFInpaintingPipeline,
							    IFInpaintingSuperResolutionPipeline,
							    IFPipeline,
							    IFSuperResolutionPipeline,
							    ImageTextPipelineOutput,
							    KandinskyImgaImgPipeline,
							    KandinskyInpaintPipeline,
							    KandinskyPipeline,
							    KandinskyPriorPipeline,
							    KandinskyVaaControlnetImgaImgPipeline,
							    KandinskyVaaControlnetPipeline,
							    KandinskyVaaImgaImgPipeline,
							    KandinskyVaaInpaintPipeline,
							    KandinskyVaaPipeline,
							    KandinskyVaaPriorEmbaEmbPipeline,
							    KandinskyVaaPriorPipeline,
							    LDMTextToImagePipeline,
							    PaintByExamplePipeline,
							    SemanticStableDiffusionPipeline,
							    ShapEImgaImgPipeline,
							    ShapEPipeline,
							    StableDiffusionAttendAndExcitePipeline,
							    StableDiffusionControlNetImgaImgPipeline,
							    StableDiffusionControlNetInpaintPipeline,
							    StableDiffusionControlNetPipeline,
							    StableDiffusionDepthaImgPipeline,
							    StableDiffusionDiffEditPipeline,
							    StableDiffusionImageVariationPipeline,
							    StableDiffusionImgaImgPipeline,
							    StableDiffusionInpaintPipeline,
							    StableDiffusionInpaintPipelineLegacy,
							    StableDiffusionInstructPixaPixPipeline,
							    StableDiffusionLatentUpscalePipeline,
							    StableDiffusionLDMaDPipeline,
							    StableDiffusionModelEditingPipeline,
							    StableDiffusionPanoramaPipeline,
							    StableDiffusionParadigmsPipeline,
							    StableDiffusionPipeline,
							    StableDiffusionPipelineSafe,
							    StableDiffusionPixaPixZeroPipeline,
							    StableDiffusionSAGPipeline,
							    StableDiffusionUpscalePipeline,
							    StableUnCLIPImgaImgPipeline,
							    StableUnCLIPPipeline,
							    TextToVideoSDPipeline,
							    TextToVideoZeroPipeline,
							    UnCLIPImageVariationPipeline,
							    UnCLIPPipeline,
							    UniDiffuserModel,
							    UniDiffuserPipeline,
							    UniDiffuserTextDecoder,
							    VersatileDiffusionDualGuidedPipeline,
							    VersatileDiffusionImageVariationPipeline,
							    VersatileDiffusionPipeline,
							    VersatileDiffusionTextToImagePipeline,
							    VideoToVideoSDPipeline,
							    VQDiffusionPipeline,
							)

try:
							if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
							from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
							if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
							from .pipelines import StableDiffusionKDiffusionPipeline

try:
							if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
							from .pipelines import (
							    OnnxStableDiffusionImgaImgPipeline,
							    OnnxStableDiffusionInpaintPipeline,
							    OnnxStableDiffusionInpaintPipelineLegacy,
							    OnnxStableDiffusionPipeline,
							    OnnxStableDiffusionUpscalePipeline,
							    StableDiffusionOnnxPipeline,
							)

try:
							if not (is_torch_available() and is_librosa_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
							from .pipelines import AudioDiffusionPipeline, Mel

try:
							if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
							from .pipelines import SpectrogramDiffusionPipeline

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_flax_objects import *  # noqa F403
else:
							from .models.controlnet_flax import FlaxControlNetModel
							from .models.modeling_flax_utils import FlaxModelMixin
							from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
							from .models.vae_flax import FlaxAutoencoderKL
							from .pipelines import FlaxDiffusionPipeline
							from .schedulers import (
							    FlaxDDIMScheduler,
							    FlaxDDPMScheduler,
							    FlaxDPMSolverMultistepScheduler,
							    FlaxKarrasVeScheduler,
							    FlaxLMSDiscreteScheduler,
							    FlaxPNDMScheduler,
							    FlaxSchedulerMixin,
							    FlaxScoreSdeVeScheduler,
							)


try:
							if not (is_flax_available() and is_transformers_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
							from .pipelines import (
							    FlaxStableDiffusionControlNetPipeline,
							    FlaxStableDiffusionImgaImgPipeline,
							    FlaxStableDiffusionInpaintPipeline,
							    FlaxStableDiffusionPipeline,
							)

try:
							if not (is_note_seq_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_note_seq_objects import *  # noqa F403
else:
							from .pipelines import MidiProcessor



