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

template <typename T>
class Matrix {
private:
    std::vector<T> data = {};
    size_t columns = 0;
    size_t lines = 0;

public:
    Matrix() = default;

    Matrix(const std::vector<std::vector<T>>& v) {
        columns = v[0].size();
        lines = v.size();
        data.resize(v.size() * v[0].size());
        for (size_t i = 0; i < v.size(); ++i) {
            for (size_t j = 0; j < v[0].size(); ++j) {
                data[i * columns + j] = v[i][j];
            }
        }
        columns = v[0].size();
        lines = v.size();
    }

    Matrix(const std::vector<T>& v, size_t c, size_t l) {
        data = v;
        columns = c;
        lines = l;
    }

    const T& element(size_t i, size_t j) const {
        return data[i * columns + j];
    }

    std::pair<size_t, size_t> size() const {
        return std::make_pair(lines, columns);
    }

    const std::vector<T>& elements() const {
        return data;
    }

    Matrix<T>& operator+= (const Matrix<T>& m) {
        for (size_t i = 0; i < data.size(); ++i) {
            data[i] += m.elements()[i];
        }
        return *this;
    }

    template <typename K>
    Matrix<T>& operator*= (const K& k) {
        for (size_t i = 0; i < data.size(); ++i) {
            data[i] *= k;
        }
        return *this;
    }

    Matrix<T>& transpose() {
        std::vector<T> new_data(data.size());
        for (size_t i = 0; i < columns; ++i) {
            for (size_t j = 0; j < lines; ++j) {
                new_data[i * lines + j] = this->element(j, i);
            }
        }
        data = std::move(new_data);
        std::swap(columns, lines);
        return *this;
    }

    Matrix<T> transposed() const {
        std::vector<T> new_data(data.size());
        for (size_t i = 0; i < columns; ++i) {
            for (size_t j = 0; j < lines; ++j) {
                new_data[i * lines + j] = this->element(j, i);
            }
        }
        Matrix<T> m(new_data, lines, columns);
        return m;
    }

    Matrix<T>& operator*= (const Matrix<T>& m) {
        std::pair<size_t, size_t> p = m.size();
        assert(columns == p.first);
        std::vector<T> new_data(lines * p.second);
        size_t curr_line = 0;
        size_t curr_column = 0;
        for (size_t k = 0; k < new_data.size(); ++k) {
            T t = T();
            if (curr_column > p.second - 1) {
                curr_line++;
                curr_column = 0;
            }
            for (size_t i = 0; i < columns; ++i) {
                t += this->element(curr_line, i) * m.element(i, curr_column);
            }
            new_data[k] = t;
            curr_column++;
        }
        data = std::move(new_data);
        columns = m.size().second;
        return *this;
    }

    typename std::vector<T>::iterator begin() {
        return data.begin();
    }

    typename std::vector<T>::iterator end() {
        return data.end();
    }

    typename std::vector<T>::const_iterator begin() const {
        return data.begin();
    }

    typename std::vector<T>::const_iterator end() const {
        return data.end();
    }
};

template <typename T>
Matrix<T> operator + (const Matrix<T>& p1, const Matrix<T>& p2) {
    Matrix<T> result = p1;
    return result += p2;
}

template <typename T, typename K>
Matrix<T> operator * (const Matrix<T>& p, const K& k) {
    Matrix<T> result = p;
    return result *= k;
}

template <typename T, typename K>
Matrix<T> operator * (const K& k, const Matrix<T>& p) {
    Matrix<T> result = p;
    return result *= k;
}

template <typename T>
Matrix<T> operator * (const Matrix<T>& p1, const Matrix<T>& p2) {
    Matrix<T> result = p1;
    return result *= p2;
}

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