


from __future__ import annotations

from decimal import Decimal

from numpy import array






def   _lowercase(					__a				:						list[list[float]]     ):
							a__      =Decimal

							# Check if the provided matrix has 2 rows and 2 columns
							# since this implementation only works for 2x2 matrices
							if len(__a     ) == 2 and len(matrix[0]     ) == 2 and len(matrix[1]     ) == 2:
														# Calculate the determinant of the matrix
														a__      =float(
														    d(matrix[0][0]     ) * d(matrix[1][1]     ) - d(matrix[1][0]     ) * d(matrix[0][1]     )     )
														if determinant == 0:
																					raise ValueError('This matrix has no inverse.'     )

														# Creates a copy of the matrix with swapped positions of the elements
														a__      =[[0.0, 0.0], [0.0, 0.0]]
														a__    ,     a__      =matrix[1][1], matrix[0][0]
														a__    ,     a__      =-matrix[1][0], -matrix[0][1]

														# Calculate the inverse of the matrix
														return [
														    [(float(d(__a     )     ) / determinant) or 0.0 for n in row] for row in swapped_matrix
														]
							elif (
							    len(__a     ) == 3
							    and len(matrix[0]     ) == 3
							    and len(matrix[1]     ) == 3
							    and len(matrix[2]     ) == 3
							):
														# Calculate the determinant of the matrix using Sarrus rule
														a__      =float(
														    (
														        (d(matrix[0][0]     ) * d(matrix[1][1]     ) * d(matrix[2][2]     ))
														        + (d(matrix[0][1]     ) * d(matrix[1][2]     ) * d(matrix[2][0]     ))
														        + (d(matrix[0][2]     ) * d(matrix[1][0]     ) * d(matrix[2][1]     ))
														    )
														    - (
														        (d(matrix[0][2]     ) * d(matrix[1][1]     ) * d(matrix[2][0]     ))
														        + (d(matrix[0][1]     ) * d(matrix[1][0]     ) * d(matrix[2][2]     ))
														        + (d(matrix[0][0]     ) * d(matrix[1][2]     ) * d(matrix[2][1]     ))
														    )     )
														if determinant == 0:
																					raise ValueError('This matrix has no inverse.'     )

														# Creating cofactor matrix
														a__      =[
														    [d(0.0     ), d(0.0     ), d(0.0     )],
														    [d(0.0     ), d(0.0     ), d(0.0     )],
														    [d(0.0     ), d(0.0     ), d(0.0     )],
														]
														a__      =(d(matrix[1][1]     ) * d(matrix[2][2]     )) - (
														    d(matrix[1][2]     ) * d(matrix[2][1]     )
														)
														a__      =-(
														    (d(matrix[1][0]     ) * d(matrix[2][2]     )) - (d(matrix[1][2]     ) * d(matrix[2][0]     ))
														)
														a__      =(d(matrix[1][0]     ) * d(matrix[2][1]     )) - (
														    d(matrix[1][1]     ) * d(matrix[2][0]     )
														)
														a__      =-(
														    (d(matrix[0][1]     ) * d(matrix[2][2]     )) - (d(matrix[0][2]     ) * d(matrix[2][1]     ))
														)
														a__      =(d(matrix[0][0]     ) * d(matrix[2][2]     )) - (
														    d(matrix[0][2]     ) * d(matrix[2][0]     )
														)
														a__      =-(
														    (d(matrix[0][0]     ) * d(matrix[2][1]     )) - (d(matrix[0][1]     ) * d(matrix[2][0]     ))
														)
														a__      =(d(matrix[0][1]     ) * d(matrix[1][2]     )) - (
														    d(matrix[0][2]     ) * d(matrix[1][1]     )
														)
														a__      =-(
														    (d(matrix[0][0]     ) * d(matrix[1][2]     )) - (d(matrix[0][2]     ) * d(matrix[1][0]     ))
														)
														a__      =(d(matrix[0][0]     ) * d(matrix[1][1]     )) - (
														    d(matrix[0][1]     ) * d(matrix[1][0]     )
														)

														# Transpose the cofactor matrix (Adjoint matrix)
														a__      =array(__a     )
														for i in range(3     ):
																					for j in range(3     ):
																												a__      =cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
														a__      =array(__a     )
														for i in range(3     ):
																					for j in range(3     ):
																												inverse_matrix[i][j] /= d(__a     )

        # Calculate the inverse of the matrix
														return [[float(d(__a     )     ) or 0.0 for n in row] for row in inverse_matrix]
							raise ValueError('Please provide a matrix of size 2x2 or 3x3.'     )





_lowerCAmelCase:						List[str]   				=       'ABCDEFGHIJKLMNOPQRSTUVWXYZ'






def   _lowercase(					):
							a__      =input('Enter message: '     )
							a__      =input('Enter key [alphanumeric]: '     )
							a__      =input('Encrypt/Decrypt [e/d]: '     )

							if mode.lower().startswith('e'     ):
														a__      ='encrypt'
														a__      =encrypt_message(__a    ,     __a     )
							elif mode.lower().startswith('d'     ):
														a__      ='decrypt'
														a__      =decrypt_message(__a    ,     __a     )

							print(f"""\n{mode.title()}ed message:"""     )
							print(__a     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'encrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str     ):
							return translate_message(__a    ,     __a    ,     'decrypt'     )






def   _lowercase(					__a				:						str    ,     __a				:						str    ,     __a				:						str     ):
							a__      =[]
							a__      =0
							a__      =key.upper()

							for symbol in message:
														a__      =LETTERS.find(symbol.upper()     )
														if num != -1:
																					if mode == "encrypt":
																												num += LETTERS.find(key[key_index]     )
																					elif mode == "decrypt":
																												num -= LETTERS.find(key[key_index]     )

																					num %= len(__a     )

																					if symbol.isupper():
																												translated.append(LETTERS[num]     )
																					elif symbol.islower():
																												translated.append(LETTERS[num].lower()     )

																					key_index += 1
																					if key_index == len(__a     ):
																												a__      =0
														else:
																					translated.append(__a     )
							return "".join(__a     )


if __name__ == "__main__":
	main()

