#include <bits/stdc++.h>
using namespace std;

int a[21][21] = {};
int s[22][22] = {};

int sum(int x1, int y1, int x2, int y2) { return s[x2][y2] - s[x1][y2] - s[x2][y1] + s[x1][y1]; }

int main() {
        int n, t;
        cin >> n >> t;
        for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                        cin >> a[i][j];
                }
        }

        for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                        s[i + 1][j + 1] = s[i + 1][j] + s[i][j + 1] - s[i][j] + a[i][j];
                }
        }

        double c[21][21] = {};
        const double alpha = .8;
        for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                        c[i][j] = 0;
                        for (int x = 0; x < n; x++) {
                                for (int y = 0; y < n; y++) {
                                        int d = abs(i - x) + abs(j - y);
                                        c[i][j] += a[x][y] * pow(alpha, d);
                                }
                        }
                }
        }
        // (1) Find the cell with the largest c
        int si = 0, sj = 0;
        double maxc = -1e18;
        for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                        if (c[i][j] > maxc) {
                                maxc = c[i][j];
                                si = i;
                                sj = j;
                        }
                }
        }

        vector<vector<bool>> visited(n, vector<bool>(n, false));
        int ci = si, cj = sj;
        visited[ci][cj] = true;
        vector<pair<int, int>> path;
        path.emplace_back(ci, cj);

        int moves = 1;
        int di[4] = {-1, 1, 0, 0}, dj[4] = {0, 0, -1, 1};
        while (moves < t) {
                int ni = -1, nj = -1;
                double best = -1e18;
                vector<pair<int, int>> candidates;
                for (int d = 0; d < 4; d++) {
                        int ti = ci + di[d], tj = cj + dj[d];
                        if (ti < 0 || ti >= n || tj < 0 || tj >= n) continue;
                        if (visited[ti][tj]) continue;
                        int adj_visited = 0;
                        for (int dd = 0; dd < 4; dd++) {
                                int ai = ti + di[dd], aj = tj + dj[dd];
                                if (ai < 0 || ai >= n || aj < 0 || aj >= n) continue;
                                if (visited[ai][aj]) adj_visited++;
                        }
                        if (adj_visited < 3) {
                                if (c[ti][tj] > best) {
                                        best = c[ti][tj];
                                        ni = ti;
                                        nj = tj;
                                }
                        } else {
                                candidates.emplace_back(ti, tj);
                        }
                }
                // If no "good" candidate, allow those with 3+ adjacent visited
                if (ni == -1 && !candidates.empty()) {
                        for (auto [ti, tj] : candidates) {
                                if (c[ti][tj] > best) {
                                        best = c[ti][tj];
                                        ni = ti;
                                        nj = tj;
                                }
                        }
                }
                if (ni == -1) break;
                ci = ni;
                cj = nj;
                visited[ci][cj] = true;
                path.emplace_back(ci, cj);
                moves++;
        }

        cout << path.size() << endl;
        for (auto [x, y] : path) {
                cout << x << ' ' << y << endl;
        }
}