#include <iostream>
#include <limits>
#include <vector>
using namespace std;
template<typename T> inline bool chmax(T &a, T b) { return ((a < b) ? (a = b, true) : (false)); }
template<typename T> inline bool chmin(T &a, T b) { return ((a > b) ? (a = b, true) : (false)); }

int main() {
    int N, T;
    cin >> N >> T;

    int a_max = numeric_limits<int>::min();
    int max_i = 0;
    int max_j = 0;

    vector<vector<int>> A(N, vector<int>(N));

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> A[i][j];
            if (A[i][j] > a_max) {
                a_max = A[i][j];
                max_i = i;
                max_j = j;
            }
        }
    }

    vector<vector<bool>> visited(N, vector<bool>(N, false));
    vector<pair<int, int>> path;

    int cur_i = max_i;
    int cur_j = max_j;
    visited[cur_i][cur_j] = true;
    path.push_back(make_pair(cur_i, cur_j));

    const int di[4] = {-1, 1, 0, 0};
    const int dj[4] = {0, 0, -1, 1};

    while ((int)path.size() < T) {
        int next_i = -1;
        int next_j = -1;
        int best_score = -1;

        for (int dir = 0; dir < 4; dir++) {
            int ni = cur_i + di[dir];
            int nj = cur_j + dj[dir];
            if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;
            if (visited[ni][nj]) continue;
            if (A[ni][nj] > best_score) {
                best_score = A[ni][nj];
                next_i = ni;
                next_j = nj;
            }
        }

        if (next_i == -1) {
            break;
        }

        cur_i = next_i;
        cur_j = next_j;
        visited[cur_i][cur_j] = true;
        path.push_back(make_pair(cur_i, cur_j));
    }

    cout << path.size() << endl;
    for (const auto &p : path) {
        cout << p.first << " " << p.second << endl;
    }

    return 0;
}