#include <bits/extc++.h>

int main() {
    using namespace std;
    unsigned N, T;
    cin >> N >> T;
    vector A(N, vector<unsigned>(N));
    for (auto&& row : A)
        for (auto&& a : row)
            cin >> a;

    vector<vector<pair<unsigned, unsigned>>> idxs;

    // 横
    idxs.emplace_back();
    idxs.back().emplace_back(0, 0);
    for (unsigned i{}; i < N; i += 2) {
        ranges::copy(views::iota(1U, N) | views::transform([i](const auto j){return make_pair(i, j);}), back_inserter(idxs.back()));
        ranges::copy(views::iota(1U, N) | views::transform([i](const auto j){return make_pair(i + 1, j);}) | views::reverse, back_inserter(idxs.back()));
    }
    ranges::copy(views::iota(1U, N) | views::transform([](const auto i){return make_pair(i, 0);}) | views::reverse, back_inserter(idxs.back()));
    // 縦
    idxs.emplace_back();
    idxs.back().emplace_back(0, 0);
    for (unsigned i{}; i < N; i += 2) {
        ranges::copy(views::iota(1U, N) | views::transform([i](const auto j){return make_pair(j, i);}), back_inserter(idxs.back()));
        ranges::copy(views::iota(1U, N) | views::transform([i](const auto j){return make_pair(j, i + 1);}) | views::reverse, back_inserter(idxs.back()));
    }
    ranges::copy(views::iota(1U, N) | views::transform([](const auto i){return make_pair(0, i);}) | views::reverse, back_inserter(idxs.back()));
    // 王
    for (unsigned k{1}; k < 19; ++k) {
        idxs.emplace_back();
        for (unsigned i{1}; i + 1 < N; i += 2) {
            ranges::copy(views::iota(0U, k) | views::transform([i](const auto j){return make_pair(i, j);}), back_inserter(idxs.back()));
            ranges::copy(views::iota(0U, k) | views::transform([i](const auto j){return make_pair(i + 1, j);}) | views::reverse, back_inserter(idxs.back()));
        }
        ranges::copy(views::iota(0U, N) | views::transform([](const auto i){return make_pair(19U, i);}), back_inserter(idxs.back()));
        for (unsigned i{N - 2}; i; i -= 2) {
            ranges::copy(views::iota(k, N) | views::transform([i](const auto j){return make_pair(i, j);}) | views::reverse, back_inserter(idxs.back()));
            ranges::copy(views::iota(k, N) | views::transform([i](const auto j){return make_pair(i - 1, j);}), back_inserter(idxs.back()));
        }
        ranges::copy(views::iota(0U, N) | views::transform([](const auto i){return make_pair(0U, i);}) | views::reverse, back_inserter(idxs.back()));
    }
    for (unsigned k{1}; k < 19; ++k) {
        idxs.emplace_back();
        for (unsigned i{1}; i + 1 < N; i += 2) {
            ranges::copy(views::iota(0U, k) | views::transform([i](const auto j){return make_pair(j, i);}), back_inserter(idxs.back()));
            ranges::copy(views::iota(0U, k) | views::transform([i](const auto j){return make_pair(j, i + 1);}) | views::reverse, back_inserter(idxs.back()));
        }
        ranges::copy(views::iota(0U, N) | views::transform([](const auto i){return make_pair(i, 19U);}), back_inserter(idxs.back()));
        for (unsigned i{N - 2}; i; i -= 2) {
            ranges::copy(views::iota(k, N) | views::transform([i](const auto j){return make_pair(j, i);}) | views::reverse, back_inserter(idxs.back()));
            ranges::copy(views::iota(k, N) | views::transform([i](const auto j){return make_pair(j, i - 1);}), back_inserter(idxs.back()));
        }
        ranges::copy(views::iota(0U, N) | views::transform([](const auto i){return make_pair(i, 0U);}) | views::reverse, back_inserter(idxs.back()));
    }

    const auto solve{[N, &A](const auto seq, unsigned T) {
        vector<unsigned> sum(N * N);
        for (const auto& [i, x] : seq | views::enumerate)
            sum[i] = A[x.first][x.second];
        for (unsigned i{}; i < N * N; ++i)
            sum.emplace_back(sum[i]);
        inclusive_scan(begin(sum), end(sum), begin(sum));
        sum.emplace(begin(sum));

        unsigned ans{}, now_idx{};
        for (unsigned i{}; i < N * N; ++i) {
            const auto now{sum[i + T] - sum[i]};
            if (now > ans) {
                ans = now;
                now_idx = i;
            }
        }
        vector<pair<unsigned, unsigned>> ret;
        ret.reserve(size(seq) * 2);
        ranges::copy(seq, back_inserter(ret));
        ranges::copy(seq, back_inserter(ret));
        return make_pair(ans, ret | views::drop(now_idx) | views::take(T) | ranges::to<vector>());
    }};

    const auto [ans, seq]{ranges::max(idxs | views::transform([T, &solve](const auto& r){return solve(r, T);}))};

    cout << size(seq) << endl;
    for (const auto& [i, j] : seq)
        cout << i << " " << j << endl;
    return 0;
}