#include <bits/stdc++.h>

using namespace std;
#ifdef INFOARENA
ifstream fin("cuplaj.in");
ofstream fout("cuplaj.out");
#define cin fin
#define cout fout
#endif // INFOARENA
class binaryFlow {
    int n, s, t;
    vector <int> lvl, rem;
    vector <vector <int>> g;

    bool bfs() {
        fill(lvl.begin(), lvl.end(), 0);
        queue <int> q; q.push(s); lvl[s] = 1;
        while(!q.empty()) {
            int top = q.front(); q.pop();
            for(int id : g[top])
                if(!lvl[edges[id].to] && edges[id].c) {
                    lvl[edges[id].to] = lvl[top] + 1;
                    q.push(edges[id].to);
                }
        }
        return lvl[t];
    }
public:
    int k;
    struct Edge {
        int from, to;
        bool c;
        Edge(int a, int b, bool _c) : from(a), to(b), c(_c) {}
    };
    vector <Edge> edges;
    binaryFlow(int _n, int _s, int _t) : n(_n), s(_s), t(_t), k(0), lvl(_n + 1, 0), rem(_n + 1, 0), g(_n + 1) {}

    void add_edge(int u, int v) {
        edges.emplace_back(u, v, true);
        edges.emplace_back(v, u, false);
        g[u].push_back(k++);
        g[v].push_back(k++);
    }

    bool dfs(int u) {
        if(u == t) return true;
        for(int& cid = rem[u]; cid < (int)g[u].size(); cid++) {
            int id = g[u][cid];
            int v = edges[id].to;
            if(!edges[id].c || lvl[v] != lvl[u] + 1) continue;
            if(!dfs(v)) continue;
            edges[id].c = false;
            edges[id ^ 1].c = true;
            return true;
        }
        return false;
    }

    int dinic() {
        int f = 0;
        while(bfs()) {
            fill(rem.begin(), rem.end(), 0);
            while(dfs(s))
                f++;
        }
        return f;
    }
};

int main()
{
    int n, m, e, u, v;
    cin >> n >> m >> e;
    binaryFlow f(n + m + 1, 0, n + m + 1);
    for(int i = 1; i <= n; i++) f.add_edge(0, i);
    for(int i = 1; i <= m; i++) f.add_edge(i + n, n + m + 1);
    for(int i = 1; i <= e; i++)
        cin >> u >> v,
        f.add_edge(u, n + v);
    cout << f.dinic() << "\n";
    for(int i = 1; i < f.k; i += 2) {
        binaryFlow :: Edge e = f.edges[i];
        swap(e.to, e.from);
        if(e.from != 0 && e.to != n + m + 1 && e.c)
            cout << e.from << " " << e.to - n << "\n";
    }
    return 0;
}