






from __future__ import annotations

import math

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				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''' )
				__magic_name__		: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      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				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      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				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      __lowercase					( snake_case ):







				"""simple docstring"""






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

				__magic_name__		:Tuple        =      len(snake_case )
				__magic_name__		:List[Any]        =      matrix_length // 2

				__magic_name__		:Optional[int]        =      [[a[i][j] for j in range(snake_case,  snake_case )] for i in range(snake_case )]
				__magic_name__		:int        =      [
				    [a[i][j] for j in range(snake_case,  snake_case )] for i in range(snake_case,  snake_case )
				]

				__magic_name__		:Dict        =      [[a[i][j] for j in range(snake_case )] for i in range(snake_case )]
				__magic_name__		:Optional[Any]        =      [[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      __lowercase					( snake_case ):







				"""simple docstring"""






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

def      __lowercase					( snake_case ):







				"""simple docstring"""






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

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






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

				__magic_name__     ,				__magic_name__     ,				__magic_name__     ,				__magic_name__		:Tuple        =      split_matrix(snake_case )
				__magic_name__     ,				__magic_name__     ,				__magic_name__     ,				__magic_name__		:List[str]        =      split_matrix(snake_case )

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

				__magic_name__		:int        =      matrix_addition(matrix_subtraction(matrix_addition(snake_case,  snake_case ),  snake_case ),  snake_case )
				__magic_name__		:List[str]        =      matrix_addition(snake_case,  snake_case )
				__magic_name__		:List[Any]        =      matrix_addition(snake_case,  snake_case )
				__magic_name__		:Optional[int]        =      matrix_subtraction(matrix_subtraction(matrix_addition(snake_case,  snake_case ),  snake_case ),  snake_case )

				# construct the new matrix from our 4 quadrants
				__magic_name__		:Union[str, Any]        =      []
				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      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






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

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

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

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














from ...processing_utils import ProcessorMixin
class 						lowerCamelCase_				(      lowerCamelCase ):
				a__					       =  '''WhisperFeatureExtractor'''
				a__					       =  '''WhisperTokenizer'''







				def __init__(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								super().__init__(__lowerCAmelCase       ,					__lowerCAmelCase     )
								__magic_name__		:int        =      self.feature_extractor
								__magic_name__		:int        =      False







				def 			A	(						self       ,					__lowerCAmelCase=None       ,					__lowerCAmelCase=None       ,					__lowerCAmelCase=True     ):
								"""simple docstring"""
								return self.tokenizer.get_decoder_prompt_ids(task=__lowerCAmelCase       ,					language=__lowerCAmelCase       ,					no_timestamps=__lowerCAmelCase     )







				def __call__(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								# For backward compatibility
								if self._in_target_context_manager:
												return self.current_processor(*__lowerCAmelCase       ,					**__lowerCAmelCase     )

								__magic_name__		:List[Any]        =      kwargs.pop('''audio'''       ,					__lowerCAmelCase     )
								__magic_name__		:Any        =      kwargs.pop('''sampling_rate'''       ,					__lowerCAmelCase     )
								__magic_name__		:str        =      kwargs.pop('''text'''       ,					__lowerCAmelCase     )
								if len(__lowerCAmelCase     ) > 0:
												__magic_name__		:Any        =      args[0]
												__magic_name__		:Union[str, Any]        =      args[1:]

								if audio is None and text is None:
												raise ValueError('''You need to specify either an `audio` or `text` input to process.'''     )

								if audio is not None:
												__magic_name__		:Optional[int]        =      self.feature_extractor(__lowerCAmelCase       ,					*__lowerCAmelCase       ,					sampling_rate=__lowerCAmelCase       ,					**__lowerCAmelCase     )
								if text is not None:
												__magic_name__		:Optional[int]        =      self.tokenizer(__lowerCAmelCase       ,					**__lowerCAmelCase     )

								if text is None:
												return inputs

								elif audio is None:
												return encodings
								else:
												__magic_name__		:str        =      encodings['''input_ids''']
												return inputs







				def 			A	(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return self.tokenizer.batch_decode(*__lowerCAmelCase       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return self.tokenizer.decode(*__lowerCAmelCase       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase="np"     ):
								"""simple docstring"""
								return self.tokenizer.get_prompt_ids(__lowerCAmelCase       ,					return_tensors=__lowerCAmelCase     )






