---

#include <iostream>
#include <locale.h>
using namespace std;

const int N = 16;

void fillMatrix(double a[N][N], int n)
{
    int num = 1;

    for (int d = 0; d < 2 * n - 1; d++)
    {
        if (d % 2 == 0) // чётная диагональ
        {
            int i;
            int j;

            if (d < n)
            {
                i = 0;
                j = n - 1 - d; // старт справа
            }
            else
            {
                i = d - n + 1;
                j = 0;
            }

            while (i < n && j < n)
            {
                a[i][j] = num;
                num = num + 1;

                i = i + 1;
                j = j + 1; // вниз-вправо
            }
        }
        else // нечётная диагональ
        {
            int i;
            int j;

            if (d < n)
            {
                i = d;
                j = n - 1;
            }
            else
            {
                i = n - 1;
                j = 2 * n - 2 - d;
            }

            while (i >= 0 && j >= 0)
            {
                a[i][j] = num;
                num = num + 1;

                i = i - 1;
                j = j - 1; // вверх-влево
            }
        }
    }
}

// Вывод матрицы
void printMatrix(double a[N][N], int n)
{
    for (int i = 0; i < n; i = i + 1)
    {
        for (int j = 0; j < n; j = j + 1)
        {
            cout << a[i][j] << "      ";
        }
        cout << endl;
    }
}

// Нахождение обратной матрицы (метод Гаусса)
bool inverse(double A[N][N], double inv[N][N], int n)
{
    double temp[N][2 * N]; // расширенная матрица

    // создаём [A | E]
    for (int i = 0; i < n; i = i + 1)
    {
        for (int j = 0; j < n; j = j + 1)
        {
            temp[i][j] = A[i][j]; // копируем A

            if (i == j)
            {
                temp[i][j + n] = 1; // единичная матрица
            }
            else
            {
                temp[i][j + n] = 0;
            }
        }
    }

    // метод Гаусса
    for (int i = 0; i < n; i = i + 1)
    {
        double diag = temp[i][i]; // главный элемент

        if (diag == 0)
        {
            return false; // делить нельзя - нет обратной
        }

        // делим строку на главный элемент
        for (int j = 0; j < 2 * n; j = j + 1)
        {
            temp[i][j] = temp[i][j] / diag;
        }

        // зануляем остальные элементы в столбце
        for (int k = 0; k < n; k = k + 1)
        {
            if (k != i)
            {
                double factor = temp[k][i];

                for (int j = 0; j < 2 * n; j = j + 1)
                {
                    temp[k][j] = temp[k][j] - factor * temp[i][j];
                }
            }
        }
    }

    // извлекаем обратную матрицу
    for (int i = 0; i < n; i = i + 1)
    {
        for (int j = 0; j < n; j = j + 1)
        {
            inv[i][j] = temp[i][j + n];
        }
    }

    return true;
}

// Умножение матриц
void multiply(double A[N][N], double B[N][N], double C[N][N], int n)
{
    for (int i = 0; i < n; i = i + 1)
    {
        for (int j = 0; j < n; j = j + 1)
        {
            C[i][j] = 0;

            for (int k = 0; k < n; k = k + 1)
            {
                C[i][j] = C[i][j] + A[i][k] * B[k][j];
            }
        }
    }
}

// Главная функция
int main()
{
    setlocale(LC_ALL, "rus");
    int n;
    cout << "n = ";
    cin >> n;

    double A[N][N];
    double inv[N][N];
    double C[N][N];

    fillMatrix(A, n);

    cout << "Исходная матрица:\n";
    printMatrix(A, n);

    if (inverse(A, inv, n) == false) // пытаемся найти обратную
    {
        cout << "Нет обратной матрицы\n";
        return 0;
    }

    cout << "Обратная матрицца:\n";
    printMatrix(inv, n);

    multiply(A, inv, C, n);

    cout << "Умножение:\n";
    printMatrix(C, n);

    return 0;
}