#include <iterator>
#include <vector>

template <typename T, int m, int n>
class Matrix {
private:
    std::vector<T> matrix;
public:
    Matrix(): matrix(m * n) {
    }
    class Row {
    private:
        std::vector<T>& matrix;
        int rowIndex;
    public:
        Row(std::vector<T>& matrix, int rowIndex): matrix(matrix), rowIndex(rowIndex) {
        }
        T& operator [] (int columnIndex) {
            return matrix[rowIndex * n + columnIndex];
        }
    };
    Matrix::Row operator [] (int rowIndex) {
        return Row(matrix, rowIndex);
    }
    class PositiveIterator: public std::iterator<std::forward_iterator_tag, int, ptrdiff_t, T*, T> {
    private:
        bool isDefault = true;
        std::vector<T>& matrix;
        int index;
        void findNext() {
            do {
                index++;
            } while (index < matrix.size() && matrix[index] <= 0);
            isDefault = index == matrix.size();
        }
        void findPrevious() {
            do {
                index--;
            } while (index >= 0 && matrix[index] <= 0);
            isDefault = index == -1;
        }
    public:
        PositiveIterator(std::vector<T>& matrix, bool isDefault): isDefault(false), matrix(matrix) {
            index = isDefault ? m * n : -1;
        }
        bool operator == (PositiveIterator other) {
            return (isDefault && other.isDefault) || (index == other.index);
        }
        bool operator != (PositiveIterator other) {
            return !(*this == other);
        }
        T& operator * () {
            if (isDefault) {
                throw "not initialized iterator";
            }
            switch (index) {
                case -1:
                    findNext();
                    break;
                case m * n:
                    findPrevious();
                    break;
            }
            return matrix[index];
        }
        PositiveIterator& operator ++ () {
            if (isDefault) {
                throw "not initialized iterator";
            }
            findNext();
            return *this;
        }
        PositiveIterator& operator ++ (int) {
            PositiveIterator& tmp = *this;
            operator++();
            return tmp;
        }
        PositiveIterator& operator -- () {
            if (isDefault) {
                throw "not initialized iterator";
            }
            findPrevious();
            return *this;
        }
        PositiveIterator& operator -- (int) {
            PositiveIterator& tmp = *this;
            operator--();
            return tmp;
        }
    };
    PositiveIterator begin() {
        return PositiveIterator(matrix, false);
    }
    PositiveIterator end() {
        return PositiveIterator(matrix, true);
    }
};