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

struct Fraction {
    long long numerator;
    long long denominator;
};

int nod(Fraction& a) {}

Fraction shorten(Fraction& a) {
    a.numerator /= nod(a);
    a.denominator /= nod(a);
    return a;
}

Fraction operator*(Fraction& lhc, const Fraction& rhc) {
    Fraction a = {lhc.numerator * rhc.numerator, lhc.denominator * rhc.denominator};
    return shorten(a);
}

struct Matrix {
    vector<vector<int>> table; //сами числа в матрице
    Fraction c; //коэффициент перед ней (работа с дробями пока не написана, поэтому можно не вникать)

};

Matrix readMatrix(int n, int m) {
    vector<vector<int>> table(n, vector<int>(m, 0));
    for (int i = 0; i != n; ++i) {
        for (int j = 0; j != m; ++j) {
            cin >> table[i][j];
        }
    }
    return {table, {1, 1}};
}

ostream& operator<<(ostream& stream, const Matrix m) {
    for (int i = 0; i != m.table.size(); ++i) {
        for (int j = 0; j != m.table[0].size(); ++j) {
            stream << m.table[i][j] << '\t';
        }
        stream << '\n';
    }
    return stream;
}

Matrix operator+(const Matrix& lhc, const Matrix& rhc) {
    vector<vector<int>> t(lhc.table.size(), vector<int>(lhc.table[0].size(), 0));
     for (int i = 0; i != t.size(); ++i) {
         for (int j = 0; j != t[0].size(); ++j) {
             t[i][j] = lhc.table[i][j] + rhc.table[i][j];
         }
     }
    return {t, {1, 1}};
}

Matrix operator-(const Matrix& lhc, const Matrix& rhc) {
    vector<vector<int>> t(lhc.table.size(), vector<int>(lhc.table[0].size(), 0));
    for (int i = 0; i != t.size(); ++i) {
        for (int j = 0; j != t[0].size(); ++j) {
            t[i][j] = lhc.table[i][j] - rhc.table[i][j];
        }
    }
    return {t, {1, 1}};
}

Matrix operator*(const Matrix& lhc, const Matrix& rhc) {
    vector<vector<int>> t(lhc.table.size(), vector<int>(lhc.table[0].size(), 0));
    for (int i = 0; i != t.size(); ++i) {
        for (int j = 0; j != t[0].size(); ++j) {
            for (int k = 0; k != lhc.table[0].size(); ++k) {
                t[i][j] += lhc.table[i][k]*rhc.table[k][j];
            }
        }
    }
    return {t, {1, 1}};
}

Matrix operator*(const int& lhc, const Matrix& rhc) {
    vector<vector<int>> t(rhc.table.size(), vector<int>(rhc.table[0].size(), 0));
    for (int i = 0; i != t.size(); ++i) {
        for (int j = 0; j != t[0].size(); ++j) {
            t[i][j] = lhc * rhc.table[i][j];
        }
    }
    return {t, {1, 1}};
}

Matrix getMatrix(Matrix matrix, int k, int l) { //получение матрицы без k-ой строки и l-ого столбца
    vector<vector<int>> t(matrix.table.size() - 1, vector<int>(matrix.table[0].size() - 1, 0));
    for (int i = 0; i != matrix.table.size(); ++i) {
        for (int j = 0; j != matrix.table[0].size(); ++j) {
            if (i == k || j == l) {
            } else if (i < k && j < l) {
                t[i][j] = matrix.table[i][j];
            } else if (i < k && j > l) {
                t[i][j - 1] = matrix.table[i][j];
            } else if (i > k && j < l) {
                t[i - 1][j] = matrix.table[i][j];
            } else if (i > k && j > l) {
                t[i - 1][j - 1] = matrix.table[i][j];
            }
        }
    }
    return {t, {1, 1}};
}

int determinant(Matrix matrix) {
    int d = 0;
    int power = 0;
    if (matrix.table.size() == 1) {
        return matrix.table[0][0];
    } else {
        for (int j = 0; j != matrix.table.size(); ++j) {
            if (j % 2 == 0) {
                power = 1;
            } else {
                power = -1;
            }
            d += power * matrix.table[0][j] * determinant(getMatrix(matrix, 0, j));
        }
        return d;
    }
}

Matrix invertibleMatrix(Matrix matrix){
    int det = determinant(matrix);
    int minus = 1;
    vector<vector<int>> invertible = matrix.table;
    for (int i = 0; i != matrix.table.size(); ++i) {
        for (int j = 0; j != matrix.table.size(); ++j){
            invertible[j][i] = minus * determinant(getMatrix(matrix, i, j));
            minus *= -1;
        }
    }
    return {invertible, {1, det}};
}

Matrix lolMatrix(Matrix matrix, int k, int l, int x) { //прибавление к k-ой строке l-ой, умноженной на x
    vector<vector<int>> t = matrix.table;
    for (int j = 0; j != matrix.table[0].size(); ++j) {
        t[k][j] += x * t[l][j];
    }
    return {t, {1, 1}};
}

int operator*(const vector<int>& lhc, const vector<int>& rhc) { // скалярное произведение
    int t = 0;
    for (int i = 0; i != lhc.size(); ++i) {
        t += lhc[i] * rhc[i];
    }
    return t;
}

vector<int> operator*(const int& lhc, vector<int> rhc) { // скалярное произведение
    for (int i = 0; i != rhc.size(); ++i) {
        rhc[i] = lhc*rhc[i];
    }
    return rhc;
}

vector<int> operator/(vector<int> lhc, const int& rhc) {
    for (int i = 0; i != lhc.size(); ++i) {
        lhc[i] = lhc[i]/rhc;
    }
    return lhc;
}