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

using namespace std;
ifstream f("cuplaj.in");
ofstream g("cuplaj.out");

int n,m,e,s,t;
vector<bool> Right;
vector<pair<int, int>> tata, RNodes;
vector<vector<pair<int, pair<int, int>>>> adj_list;

void citire(){
    f >> n >> m >> e;
    s = 0;
    t = n+m+1;
    adj_list.resize(t+1);
    Right.resize(m+1);
    tata.resize(t+1);
    for(int i = 1; i <= n; i++)
    {
        adj_list[s].push_back({i, {1, adj_list[i].size()}});
        adj_list[i].push_back({s, {0, adj_list[s].size()-1}});
        if(i == t)
            RNodes.emplace_back(s, adj_list[s].size()-1);
    }
    for(int i = 1; i <= e; i++){
        int u, v;
        f >> u >> v;
        adj_list[u].push_back({n+v, {1, adj_list[n+v].size()}});
        adj_list[n+v].push_back({u, {0, adj_list[u].size()-1}});
        if(n+v == t)
            RNodes.emplace_back(u, adj_list[u].size()-1);
        Right[v] = true;
    }
    for(int i = 1; i <= m; i++)
        if(Right[i])
        {
            adj_list[n+i].push_back({t, {1, adj_list[t].size()}});
            adj_list[t].push_back({n+i, {0, adj_list[n+i].size()-1}});
            if(t == t)
                RNodes.emplace_back(n+i, adj_list[n+i].size()-1);
        }
}

bool BFS(){
    vector<bool> viz(t+1);
    queue<int> coada;
    coada.push(s);
    viz[s] = true;
    tata[s] = {-1, -1};
    while(!coada.empty()){
        int u = coada.front();
        coada.pop();
        if(u == t)
            continue;
        int i = 0;
        for(auto node: adj_list[u]){
            int v, p;        // nod, capacitate
            v = node.first;
            p = node.second.first;
            if(!viz[v] && p){
                tata[v] = {u, i};
                viz[v] = true;
                coada.push(v);
            }
            i++;
        }
    }
    return viz[t];
}

long maxxFlow(){
    long maxFlow = 0;
    while(BFS()) {
        for (auto node: RNodes) {
            int u, v, i, j, minPath = 1;
            tata[t] = node;
            v = t;
            while (tata[v].first != -1) {
                u = tata[v].first;
                i = tata[v].second;
                minPath = min(minPath, adj_list[u][i].second.first);
                v = u;
            }
            v = t;
            while (tata[v].first != -1) {
                u = tata[v].first;
                i = tata[v].second;
                j = adj_list[u][i].second.second;
                adj_list[u][i].second.first -= minPath;
                adj_list[v][j].second.first += minPath;
                v = u;
            }
            maxFlow += minPath;
        }
    }
    return maxFlow;
}
void afisare()
{
    g << maxxFlow() << '\n';
    for(int i = 1; i <= n; i++)
        for(auto node: adj_list[i]){
            int u, v;
            u = node.first;
            v = node.second.first;
            if(u && v == 0 && u != t)
                g << i << " " << u-n << '\n';
        }
}
int main(){
    citire();
    afisare();
    return 0;
}