





from __future__ import annotations

import math

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

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :list			,							snake_case__  :list     )      ->						Optional[Any]:
  return [
      [matrix_a[row][col] - matrix_b[row][col] for col in range(len(matrix_a[row]     )     )]
      for row in range(len(snake_case__     )     )
  ]

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

  _lowercase							= len(snake_case__     )
  _lowercase							= matrix_length // 2

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

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

  return top_left, top_right, bot_left, bot_right

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

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

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

  _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= split_matrix(snake_case__     )
  _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= split_matrix(snake_case__     )

  _lowercase							= actual_strassen(snake_case__			,							matrix_subtraction(snake_case__			,							snake_case__     )     )
  _lowercase							= actual_strassen(matrix_addition(snake_case__			,							snake_case__     )			,							snake_case__     )
  _lowercase							= actual_strassen(matrix_addition(snake_case__			,							snake_case__     )			,							snake_case__     )
  _lowercase							= actual_strassen(snake_case__			,							matrix_subtraction(snake_case__			,							snake_case__     )     )
  _lowercase							= actual_strassen(matrix_addition(snake_case__			,							snake_case__     )			,							matrix_addition(snake_case__			,							snake_case__     )     )
  _lowercase							= actual_strassen(matrix_subtraction(snake_case__			,							snake_case__     )			,							matrix_addition(snake_case__			,							snake_case__     )     )
  _lowercase							= actual_strassen(matrix_subtraction(snake_case__			,							snake_case__     )			,							matrix_addition(snake_case__			,							snake_case__     )     )

  _lowercase							= matrix_addition(matrix_subtraction(matrix_addition(snake_case__			,							snake_case__     )			,							snake_case__     )			,							snake_case__     )
  _lowercase							= matrix_addition(snake_case__			,							snake_case__     )
  _lowercase							= matrix_addition(snake_case__			,							snake_case__     )
  _lowercase							= matrix_subtraction(matrix_subtraction(matrix_addition(snake_case__			,							snake_case__     )			,							snake_case__     )			,							snake_case__     )

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

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :list			,							snake_case__  :list     )      ->						list:
  if matrix_dimensions(snake_case__     )[1] != matrix_dimensions(snake_case__     )[0]:
    _lowercase							= (
        'Unable to multiply these matrices, please check the dimensions.\n'
        F"""Matrix A: {matrixa}\n"""
        F"""Matrix B: {matrixa}"""
    )
    raise Exception(snake_case__     )
  _lowercase							= matrix_dimensions(snake_case__     )
  _lowercase							= matrix_dimensions(snake_case__     )

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

  _lowercase							= max(*snake_case__			,							*snake_case__     )
  _lowercase							= int(math.pow(2			,							math.ceil(math.loga(snake_case__     )     )     )     )
  _lowercase							= matrixa
  _lowercase							= matrixa

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

  _lowercase							= actual_strassen(snake_case__			,							snake_case__     )

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


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






snake_case 				=       """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