#include <iostream>
#include <algorithm>
using namespace std;

double** getTransposed(double** matrix)
{
	double** transposed = new double*[3];
	for (int i = 0; i < 3; i++) transposed[i] = new double[3];
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			transposed[j][i] = matrix[i][j];
		}
	}

	return transposed;
}

void multiply(double** matrix, double number)
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			matrix[i][j] *= number;
		}
	}
}

double** multiplyMatrix(double** matrix, double** another)
{
	double** product = new double*[3];
	for (int i = 0; i < 3; i++) product[i] = new double[3];

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			double result = 0;
			for (int k = 0; k < 3; k++)
			{
				result += matrix[i][k] * another[k][j];
			}
			product[i][j] = result;
		}
	}

	return product;
}

void add(double** matrix, double number)
{
	for (int i = 0; i < 3; i++)
	{
		matrix[i][i] += number;
	}
}

void divide(double** matrix, double number)
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			matrix[i][j] /= number;
		}
	}
}

double getMinor(double** matrix, int row, int column)
{
	double numbers[4];
	int index = 0;

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			if (i != row && j != column)
			{
				numbers[index] = matrix[i][j];
				index++;
			}
		}
	}

	return numbers[0] * numbers[3] - numbers[1] * numbers[2];
}

double getThreeDimensionDeterminant(double** matrix)
{
	double firstSum = matrix[0][0] * matrix[1][1] * matrix[2][2]
		+ matrix[0][1] * matrix[1][2] * matrix[2][0]
		+ matrix[1][0] * matrix[2][1] * matrix[0][2];

	double secondSum = matrix[0][2] * matrix[1][1] * matrix[2][0]
		+ matrix[0][1] * matrix[1][0] * matrix[2][2]
		+ matrix[1][2] * matrix[2][1] * matrix[0][0];

	return firstSum - secondSum;
}

double** getInverse(double** matrix)
{
	double** transposed = getTransposed(matrix);

	double** minorMatrix = new double*[3];
	for (int i = 0; i < 3; i++) minorMatrix[i] = new double[3];

	int multiplier = 1;

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			minorMatrix[i][j] = getMinor(transposed, i, j)*multiplier;
			multiplier *= -1;
		}
	}

	int determinant = getThreeDimensionDeterminant(matrix);

	divide(minorMatrix, determinant);

	delete[] transposed;
	return minorMatrix;
}

double** calculateResult(double** a, double** c)
{
	//-3AtC
	double** aTransposed = getTransposed(a);
	multiply(aTransposed, -3);

	double** rightSide = multiplyMatrix(aTransposed, c);

	//X(A+5)
	add(a, 5);

	double** aInverse = getInverse(a);
	rightSide = multiplyMatrix(rightSide, aInverse);

	delete[] aTransposed;
	delete[] aInverse;
	return rightSide;
}

int main()
{
	double** a = new double*[3];
	for (int i = 0; i < 3; i++) a[i] = new double[3];

	double** c = new double*[3];
	for (int i = 0; i < 3; i++) c[i] = new double[3];

	cout << "A = ";
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cin >> a[i][j];
		}
	}

	cout << "C = ";
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cin >> c[i][j];
		}
	}

	double** result = calculateResult(a, c);
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << result[i][j]<<" ";
		}
		cout << endl;
	}

	delete[] result;
	delete[] a;
	delete[] c;

	system("pause");
	return 0;
}