#include <iostream>
#include <vector>

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

 public:
    Matrix(const std::vector<std::vector<T> >& d)
    : data(d) {
    }

    const T& operator() (std::size_t i, std::size_t j) const {
        return data[i][j];
    }

    const std::pair<std::size_t, std::size_t> size() const {
        return std::pair<std::size_t, std::size_t> (data.size(), data[0].size());
    }

    Matrix& operator += (const Matrix& other) {
        for (std::size_t i = 0; i != other.size().first; ++i)
            for (std::size_t j = 0; j != other.size().second; ++j)
                data[i][j] += other.data[i][j];
        return *this;
    }

    Matrix operator + (const Matrix& other) const {
        auto C = *this;
        C += other;
        return C;
    }

    template <typename M>
    Matrix& operator *=(const M& number) {
        size_t s = data.size(), v = data[0].size();
        for (std::size_t i = 0; i <= s - 1; ++i) {
            for (std::size_t j = 0; j <= v - 1; ++j) {
                data[i][j] = data[i][j] * number;
            }
        }
        return *this;
    }

    template <typename M>
    Matrix operator * (const M& number) const {
        auto C = *this;
        C *= number;
        return C;
    }
};


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