#include <iostream>
#include <vector>
#include <utility>
#include <cassert>

using namespace std;

template<typename T>
class Matrix {
private:
    vector<vector<T>> m;

public:
    Matrix(const vector<vector<T>> &x) {
        m = x;
    }

    pair<size_t, size_t> size() const {
        size_t a = m.size();
        size_t b = m[0].size();
        return {a, b};
    }

    const vector<T> &operator[](size_t i) const {
        return m[i];
    }

    vector<T> &operator[](size_t i) {
        return m[i];
    }

    Matrix<T> &operator*=(const Matrix<T> &other) {
        assert(size().second == other.size().first);
        Matrix<T> tmp(*this);
        tmp = *this * other;
        *this = tmp;
        return *this;
    }
};

template<typename T>
std::ostream &operator<<(std::ostream &out, const Matrix<T> &m) {
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < m.size().second; ++j) {
            if (j != 0 && j != m.size().second) {
                out << '\t';
            }
            out << m[i][j];
        }
        if (i != m.size().first - 1) {
            out << '\n';
        }
    }
    return out;
}

template<typename T>
Matrix<T> &operator+=(Matrix<T> &m, const Matrix<T> &m_other) {
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < m.size().second; ++j) {
            m[i][j] += m_other[i][j];
        }
    }
    return m;
}

template<typename T>
Matrix<T> operator+(const Matrix<T> &m, const Matrix<T> &m_other) {
    Matrix<T> tmp(m);
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < m.size().second; ++j) {
            tmp[i][j] = m[i][j] + m_other[i][j];
        }
    }
    return tmp;
}

template<typename T>
Matrix<T> &operator*=(Matrix<T> &m, const int &ch) {
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < m.size().second; ++j) {
            m[i][j] *= ch;
        }
    }
    return m;
}

template<typename T>
Matrix<T> operator*(const Matrix<T> &m, const int &ch) {
    Matrix<T> tmp(m);
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < m.size().second; ++j) {
            tmp[i][j] = m[i][j] * ch;
        }
    }
    return tmp;
}


template<typename T>
Matrix<T> operator*(const Matrix<T> &m, const Matrix<T> &other) {
    assert(m.size().second == other.size().first);
    vector<vector<T>> x;
    x.resize(m.size().first);
    for (size_t i = 0; i != m.size().first; ++i) {
        x[i].resize(other.size().second);
        for (size_t j = 0; j != other.size().second; ++j) {
            x[i][j] = T();
        }
    }
    Matrix<T> tmp(x);
    for (size_t i = 0; i < m.size().first; ++i) {
        for (size_t j = 0; j < other.size().second; ++j) {
            for (size_t k = 0; k < m.size().second; ++k) {
                tmp[i][j] += m[i][k] * other[k][j];
            }
        }
    }
    return tmp;
}