#include <bits/stdc++.h>

using namespace std;
using i64 = long long;

#define rep(i, l, r) for (int i = (l); i < (r); ++i)
#define per(i, l, r) for (int i = (r - 1); i >= (l); --i)
#define ALL(x) (x).begin(), (x).end()

int main() {
    int N, M;
    cin >> N >> M;
    vector<int> A(N * M);
    for (auto &e : A) {
        cin >> e;
        --e;
    }

    vector<vector<int>> fCount(N, vector<int>(M));
    vector<bool> isT(N * M);
    rep (i, 0, N) {
        rep (j, i * M, (i + 1) * M) {
            if (++fCount[i][A[j]] >= 2) {
                isT[j] = true;
            }
        }
    }

    vector<vector<int>> graph(N * M + N + M);
    rep (i, 0, N * M) {
        if (isT[i]) {
            graph[i].push_back(N * M + N + A[i]);
        }
    }
    rep (i, 0, N) {
        int p = 0;
        rep (j, 0, M) {
            if (fCount[i][j] == 0) {
                graph[N * M + N + j].push_back(N * M + i);
                while (not isT[i * M + p]) {
                    ++p;
                }
                graph[N * M + i].push_back(i * M + p);
                ++p;
            }
        }
    }

    /*
    rep (i, 0, N * M + N + M) {
        for (const auto t : graph[i]) {
            cout << i << ' ' << t << endl;
        }
    }
    cout << endl;
    */

    vector<bool> isSeen(2 * N * M + M);
    auto dfs = [&](auto &&self, const int v, vector<int> &trail) -> void {
        isSeen[v] = true;
        while (not graph[v].empty()) {
            const int t = graph[v].back();
            graph[v].pop_back();
            self(self, t, trail);
        }
        trail.push_back(v);
    };

    int ans = 0;
    vector<pair<int, int>> ways;
    rep (f, 0, N * M) {
        if (isSeen[f]) continue;
        if (graph[f].empty()) continue;
        vector<int> trail;
        dfs(dfs, f, trail);
        reverse(ALL(trail));
        vector<int> path;
        for (const auto e : trail) {
            if (e < N * M) {
                path.push_back(e);
            }
        }
        // assert(path[0] == path[path.size() - 1]);
        ans += path.size();

        int p = N * M;
        for (const auto e : path) {
            ways.push_back({p, e});
            p = e;
        }
        ways.push_back({p, N * M});
    }

    cout << ans << endl;
    for (const auto &[a, b] : ways) cout << a << ' ' << b << endl;
}