#include <bitset>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <cmath>

using namespace std;

map <pair<int, int>, long double> calculatedMinorsDets;

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[columnNumber];

    for (int i = 0; i < rowNumber; i++)
    {
        for (int j = 0; j < columnNumber; 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;
}

long double calculateDeterminant(long double** matrix, int matrixSize, int currentMatrixSize, pair<int, int> minorMask)
{
    //if det has calculated return it
    if (calculatedMinorsDets.find(minorMask) != calculatedMinorsDets.end())
        return calculatedMinorsDets[minorMask];

    long double ans = 0;

    //base case 1by1 matrix
    if (currentMatrixSize == 1)
        return matrix[0][0];

    //base case 2by2 matrix
    if (currentMatrixSize == 2)
    {
        int ci1 = -1, ci2 = -1, ri1 = -1, ri2 = -1;
        for (int i = 0; i < matrixSize; i++)
        {
            if (minorMask.first & (1 << (matrixSize - 1 - i)))
            {
                ri1 = (ri1 == -1 ? i : ri1);
                ri2 = (ri2 == -1 && ri1 != -1 ? i : ri2);
            }
            if (minorMask.second & (1 << (matrixSize - 1 - i)))
            {
                ci1 = (ci1 == -1 ? i : ci1);
                ci2 = (ci2 == -1 && ci1 != -1 ? i : ci2);
            }
        }

        calculatedMinorsDets[minorMask] = matrix[ri1][ci1] * matrix[ri2][ci2] - matrix[ri1][ci2] * matrix[ri2][ci1];
        return calculatedMinorsDets[minorMask];
    }

    //recursive calls

    int ri = 0, sign = 1;
    while (!(minorMask.first & (1 << (matrixSize - 1 - ri))))
        ri++;

    for (int ci = 0; ci < matrixSize; ci++)
    {
        if (minorMask.second & (1 << (matrixSize - 1 - ci)))
        {
            ans += sign * matrix[ri][ci] * calculateDeterminant(matrix, matrixSize, currentMatrixSize - 1, { minorMask.first ^ (1 << (matrixSize - 1 - ri)), minorMask.first ^ (1 << (matrixSize - 1 - ri)) });
            sign = -sign;
        }
    }

    calculatedMinorsDets[minorMask] = ans;

    return ans;
}


void calculateInverseMatrix(long double** matrix, int matrixSize, long double** inverseMatrix)
{
    pair<int, int> minorMask = { (1 << (matrixSize)) - 1,(1 << (matrixSize)) - 1 };
    long double determinant = calculateDeterminant(matrix, matrixSize, matrixSize, minorMask);

    for (int i = 0; i < matrixSize; i++)
    {
        for (int j = 0; j < matrixSize; j++)
        {
            inverseMatrix[j][i] = calculateDeterminant(matrix, matrixSize, matrixSize - 1, { minorMask.first ^ (1 << (matrixSize - 1 - i)), minorMask.first ^ (1 << (matrixSize - 1 - 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)
        exit(-1);

    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[r_a][c_b] = 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()
{
    //cout << calculatedMinors[{0,0}] << endl;


    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";
    }

    long double** inverse = createMatrix(n, n);
    calculateInverseMatrix(A_T_A, n, inverse);

    out << "\n(A_T*A)_-1:\n";
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            out << inverse[i][j] << " ";
        out << "\n";
    }

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

    long double** x = multiplyMatrices(proj, n, m, b, m, 1);
    out << "\nx:\n";
    for (int i = 0; i < n; i++)
        out << x[i][0] << "\n";
}