#include <iostream>
#include <vector>
#include <queue>


using namespace std;

struct edge {
    int to;
    int capacity, flow;
    int back_index;

    edge(int to, int c, int bi) : to(to), capacity(c), flow(0), back_index(bi) {};

    int residual() {
        return capacity - flow;
    }

    bool saturated() {
        return flow == capacity;
    }
};

typedef vector<vector<edge>> graph;

graph g;
vector<int> d;
vector<int> p;

int s, t;
long long limit;

bool bfs() {
    d.assign(g.size(), g.size() + 1);
    d[s] = 0;
    queue<int> q;
    q.push(s);

    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (auto &u : g[v]) {
            if (d[u.to] > d[v] + 1 && u.residual() >= limit) {
                d[u.to] = d[v] + 1;
                q.push(u.to);
            }
        }
    }

    return d[t] != g.size() + 1;
}

int dfs(int v, int flow) {
    if (v == t || flow == 0) {
        return flow;
    }

    for (; p[v] < g[v].size(); p[v]++) {
        auto &u = g[v][p[v]];
        if (d[u.to] == d[v] + 1 && u.residual() >= limit) {
            int delta = dfs(u.to, min(flow, u.residual()));
            if (delta != 0) {
                u.flow += delta;
                g[u.to][u.back_index].flow -= delta;
                return delta;
            }
        }
    }

    return 0;
}

long long max_flow() {
    long long flow = 0;

    for (limit = 1u << 30; limit > 0; limit >>= 1) {
        while (bfs()) {
            p.assign(g.size(), 0);
            long long f = dfs(s, INT32_MAX);

            while (f != 0) {
                flow += f;
                f = dfs(s, INT32_MAX);
            }
        }
    }

    return flow;
}

int main() {
    freopen("t.txt", "r", stdin);
    freopen("planaritycheck.out", "w", stdout);

    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    unsigned int n, m;
    cin >> n >> m;
    g.assign(n + m + 2, {});
    vector<pair<int, int>> data;
    g.reserve(m);
    for (int i = 1; i <= n; i++) {
        g[0].emplace_back(i, 300, i - 1);
    }
    for (int i = 1; i <= m; i++) {
        g[n + i].emplace_back(n + m + 1, 300, g[n + i].size());
    }
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        while (x != 0) {
            g[i].emplace_back(x + n, 1, g[i].size());
            g[x + n].emplace_back(i, 1, g[i].size() - 1);
            data.emplace_back(make_pair(i, x));
            cin >> x;
        }
    }
    s = 0;
    t = n + m;
    cout << max_flow() << endl;
    for (int i = 0; i < data.size(); i++) {
        if (g[data[i].first][data[i].second].flow) {
            cout << data[i].first << " " << data[i].second << endl;
        }

    }
}