#include <iostream>
#include <vector>

template <typename T>
class Matrix {
private:
    std::vector<std::vector<T>> mass;
public:
    Matrix(const std::vector<std::vector<T>>& m) {
        mass = m;
    }

    const std::pair<size_t, size_t> size() const {
        std::pair<size_t, size_t> res;
        res.first = mass.size();
        res.second = mass[0].size();
        return res;
    }

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

    const std::vector<T> operator[] (size_t i) const {
        return mass[i];
    }
};

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 == m.size().second - 1) {
                out << m[i][j];
            } else {
                out << m[i][j] << "\t";
            }
        }
        if (i != m.size().first - 1) {
            out << "\n";
        }
    }
    return out;
}

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

template <typename T>
Matrix<T> operator + (const Matrix<T>& first, const Matrix<T>& second) {
    Matrix<T> a = first;
    a += second;
    return a;
}

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

template <typename T, typename N>
Matrix<T> operator * (const Matrix<T>& first, const N& x) {
    Matrix<T> a = first;
    a *= x;
    return a;
}

int main() {
    int m, n;
    std::cin >> n >> m;
    std::vector<std::vector<int>> a(n, std::vector<int>(m));
    for (size_t i = 0; i < a.size(); ++i) {
        for (size_t j = 0; j < a[0].size(); ++j) {
            std::cin >> a[i][j];
        }
    }
    Matrix<int> b = a;
    Matrix<int> c = a;
    b += c *= 3;
    std::cout << b;
}