#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>

using namespace std;
const int DIM_MAX = 3005;
int cap[DIM_MAX][DIM_MAX];   
int fl[DIM_MAX][DIM_MAX];    
int vizitat[DIM_MAX];        
int tata[DIM_MAX];           
vector<int> adj[DIM_MAX];

ifstream in("cuplaj.in");
ofstream out("cuplaj.out");

int bfs(int sursa, int destinatie, int nr_noduri) {
    for (int i = 0; i <= nr_noduri; i++) {
        tata[i] = -1;
        vizitat[i] = 0;  
    }

    vizitat[sursa] = 1;
    queue<int> coada;
    coada.push(sursa);

    while (!coada.empty()) {
        int nod_curent = coada.front();
        coada.pop();
        if (nod_curent == destinatie) continue;

        for (auto urmator : adj[nod_curent]) {
            //capacitatea reziduala
            if (!vizitat[urmator] && cap[nod_curent][urmator] - fl[nod_curent][urmator] > 0) {
                vizitat[urmator] = 1;
                tata[urmator] =nod_curent;
                coada.push(urmator);    
            }
        }
    }
    if (vizitat[destinatie] == 0) {
        return 0;
    }

   //flux minim
    int flux_curent = 1e9;
    int nod= destinatie;
    while (nod != sursa) {
        int parinte = tata[nod];
        flux_curent = min(flux_curent, cap[parinte][nod] - fl[parinte][nod]);
        nod = parinte;
    }

    nod =destinatie;
    while (nod != sursa) {
        int parinte = tata[nod];
        fl[parinte][nod] += flux_curent;
        fl[nod][parinte] -= flux_curent;
        nod = parinte;
    }
    return flux_curent;
}

int main() {
    int stg, drp, muchii; 
    in >> stg >> drp >> muchii;
    int total_noduri = stg + drp + 2;

    if (total_noduri >= DIM_MAX) {
        out<<0<<'\n';
        return 0;
    }

    int src= 0;                    
    int dest= stg + drp + 1; 
 
    for (int i = 1; i <= stg; i++) {
        cap[src][i] = 1;
        adj[src].push_back(i);
        adj[i].push_back(src);
    }

    
    for (int i = 1; i <= drp; i++) {
        int nod_dr = stg + i;
        cap[nod_dr][dest] = 1;
        adj[nod_dr].push_back(dest);
        adj[dest].push_back(nod_dr);
    }
    
    for (int i = 1; i <= muchii; i++) {
        int u, v;
        in>>u>>v;
        int nod_v_dec = stg + v; 

        if (cap[u][nod_v_dec] == 0) {
            cap[u][nod_v_dec] = 1;
            adj[u].push_back(nod_v_dec);
            adj[nod_v_dec].push_back(u);
        }
    }

    int flux_total = 0;
    while (true) {
        int adaos = bfs
    (src, dest, dest);
        if (adaos == 0) {
            break;
        }
        flux_total += adaos;
    }

    out<<flux_total<<'\n';
   
    for (int i = 1; i <= stg; i++) {
        for (auto vec : adj[i]) {
            
            if (vec > stg && vec <= stg + drp) {
                if (fl[i][vec] == 1) {
                    out << i << " " << (vec - stg) << '\n';
                }
            }
        }
    }
    return 0;
}