#include <iostream>
#include <vector>

template <size_t rows, size_t cols, typename T>
class Matrix {
public:
    Matrix() {
        data.resize(rows, std::vector<T>(cols));
    }

    Matrix(const std::vector<std::vector<T>>& inputData) {
        if (inputData.size() != rows || inputData[0].size() != cols) {
            throw std::invalid_argument("Invalid matrix dimensions");
        }

        data = inputData;
    }

    Matrix<rows, cols, T> operator+(const Matrix<rows, cols, T>& other) const {
        Matrix<rows, cols, T> result;

        for (size_t i = 0; i < rows; i++) {
            for (size_t j = 0; j < cols; j++) {
                result[i][j] = data[i][j] + other[i][j];
            }
        }

        return result;
    }

    std::vector<T>& operator[](size_t rowIndex) {
        if (rowIndex >= rows) {
            throw std::out_of_range("Row index out of range");
        }

        return data[rowIndex];
    }

    const std::vector<T>& operator[](size_t rowIndex) const {
        if (rowIndex >= rows) {
            throw std::out_of_range("Row index out of range");
        }

        return data[rowIndex];
    }

    size_t numRows() const {
        return rows;
    }

    size_t numCols() const {
        return cols;
    }

private:
    std::vector<std::vector<T>> data;
};

template <size_t rows, size_t cols, typename T>
std::ostream& operator<<(std::ostream& os, const Matrix<rows, cols, T>& matrix) {
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            os << matrix[i][j] << ' ';
        }

        os << '\n';
    }

    return os;
}

int main() {
    Matrix<3, 3, int> matrixA({ {1, 2, 3}, {4, 5, 6}, {7, 8, 9} });
    Matrix<3, 3, int> matrixB({ {9, 8, 7}, {6, 5, 4}, {3, 2, 1} });

    Matrix<3, 3, int> matrixC = matrixA + matrixB;

    std::cout << "Matrix A:\n" << matrixA;
    std::cout << "Matrix B:\n" << matrixB;
    std::cout << "Matrix C (A + B):\n" << matrixC;

    return 0;
}