#include <fstream>
#include <iomanip>
#include <iostream>

using namespace std;

long double calculateDeterminant(long double** matrix, int matrixSize);

long double calculateMinor(long double** matrix, int matrixSize, int row, int column);

long double** createMatrix(int rowNumber, int columnNumber)
{
	auto** matrix = new long double* [rowNumber];

	for (int i = 0; i < rowNumber; i++)
		matrix[i] = new long double[rowNumber];

	for (int i = 0; i < rowNumber; i++)
	{
		for (int j = 0; j < rowNumber; j++)
			matrix[i][j] = 0;
	}

	return matrix;
}

void deleteMatrix(long double** matrix, int sizeMatrix)
{
	for (int i = 0; i < sizeMatrix; i++)
		delete[] matrix[i];

	delete matrix;
}

void createNewMatrixOnBaseWithoutRowAndCol(long double** matrix, long double** newMatrix, int matrixSize, int row, int column)
{
	bool skipRow = false;

	for (int i = 0; i < matrixSize - 1; i++)
	{
		bool skipColumn = false;

		if (row == i)
			skipRow = true;

		for (int j = 0; j < matrixSize - 1; j++)
		{
			if (column == j)
				skipColumn = true;

			newMatrix[i][j] = matrix[i + (skipRow == true ? 1 : 0)][j + (skipColumn == true ? 1 : 0)];
		}
	}
}

long double calculateDeterminant(long double** matrix, int matrixSize)
{
	static int initialSize = 0;
	if (initialSize == 0)
		initialSize = matrixSize;

	long double ans = 0;

	if (matrixSize == 1)
		return matrix[0][0];
	if (matrixSize == 2)
		return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];

	for (int i = 0; i < matrixSize; i++)
	{
		ans += matrix[0][i] * calculateMinor(matrix, matrixSize, 0, i);
	}

	if (matrixSize != initialSize)
		deleteMatrix(matrix, matrixSize);

	return ans;
}

long double calculateMinor(long double** matrix, int matrixSize, int row, int column)
{
	long double** newMatrix = createMatrix(matrixSize - 1, matrixSize - 1);
	createNewMatrixOnBaseWithoutRowAndCol(matrix, newMatrix, matrixSize, row, column);

	return pow(-1, row + column) * calculateDeterminant(newMatrix, matrixSize - 1);
}

void calculateInverseMatrix(long double** matrix, int matrixSize, long double** inverseMatrix)
{
	long double determinant = calculateDeterminant(matrix, matrixSize);

	for (int i = 0; i < matrixSize; i++)
	{
		for (int j = 0; j < matrixSize; j++)
		{
			inverseMatrix[j][i] = calculateMinor(matrix, matrixSize, i, j) / determinant;
		}
	}
}

long double** multiplyMatrices(long double** a, int a_rowNumber, int a_columnNumber, long double** b, int b_rowNumber, int b_columnNumber)
{
	if (a_columnNumber != b_rowNumber)
		throw exception("Multiplication of these matrices is impossible");

	auto multiplicationMatrix = createMatrix(a_rowNumber, b_columnNumber);

	for (int r_a = 0; r_a < a_rowNumber; r_a++)
	{
		for (int c_b = 0; c_b < b_columnNumber; c_b++)
		{
			long double result = 0.0;

			for (int c_a = 0, r_b = 0; c_a < a_columnNumber && r_b < b_rowNumber; c_a++, r_b++)
			{
				result += a[r_a][c_a] * b[r_b][c_b];
			}

			multiplicationMatrix[c_b][r_a] = result;
		}
	}

	return multiplicationMatrix;
}

long double** transposeMatrix(long double** a, int a_rowNumber, int a_columnNumber)
{
	long double** result = createMatrix(a_columnNumber, a_rowNumber);

	for (int i = 0; i < a_rowNumber; i++)
	{
		for (int j = 0; j < a_columnNumber; j++)
		{
			result[j][i] = a[i][j];
		}
	}

	/*for (int i = 0; i < a_columnNumber; i++)
	{
		for (int j = 0; j < a_rowNumber; j++)
		{
			cout << result[i][j] << " ";
		}
		cout << endl;
	}*/


	return result;
}

int main()
{
	ifstream in("input.txt");
	ofstream out("output.txt");
	out << fixed << setprecision(2);

	int n, m;
	in >> n >> m;
	n++;

	auto A = createMatrix(m, n);
	auto b = createMatrix(m, 1);

	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j <= n; j++)
		{
			if (j == 0)
				A[i][0] = 1.0;
			else
			{
				if (j != n)
					in >> A[i][j];
				else in >> b[i][0];
			}
		}
	}

	out << "A:\n";
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
			out << A[i][j] << " ";
		out << "\n";
	}

	out << "\nb:\n";
	for (int i = 0; i < m; i++)
		out << b[i][0] << "\n";

	long double** A_T = transposeMatrix(A, m, n);

	long double** A_T_A = multiplyMatrices(A_T, n, m, A, m, n);
	out << "\nA_T*A:\n";
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
			out << A_T_A[i][j] << " ";
		out << "\n";
	}

}