#include <fstream>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;

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

//O(N*M^2)
//n - numarul de noduri
//m - numarul de muchii

int n, m, x, a, b, flow, graf[10001][10001], graf2[10001][10001], flux_max;
queue<pair<int, int>> q;
bool viz[10001];
int parent[10001];

int bfs(){
    while(!q.empty())
        q.pop();

    for(int i = 0; i <= n + m + 1; i++){
        parent[i] = 0;
        viz[i] = false;
    }

    //in coada este retinut nodul si capacitatea
    q.push({0, 110001});
    viz[0] = true;

    while(!q.empty()){
        int nod = q.front().first;
        int flux = q.front().second;
        q.pop();

        //cautam care sunt vecinii nodului curent si vedem daca a fost vizitat
        //daca nu vedem care este fluxul minim pana la acel nod si il retinem
        //daca am ajuns la destinatie returnam fluxul
        for(int i = 0; i <= n + m + 1; i++){
            if(!viz[i] && graf[nod][i] > 0){
                parent[i] = nod;
                viz[i] = true;

                int new_flux = min(flux, graf[nod][i]);
                if(i == n + m + 1)
                    return new_flux;
                q.push({i, new_flux});
            }
        }
    }
    return 0;
}

int flux_maxim(){
    int flux = bfs();

    //daca am gasit un path atunci adunam fluxul la total si trecem prin path folosind vectorul de tati ca sa reconstruim graful
    while(flux){
        flux_max += flux;
        int nod_curent = n + m + 1;

        while(nod_curent != 0){
            int prev = parent[nod_curent];
            graf[nod_curent][prev] += flux;
            graf[prev][nod_curent] -= flux;
            nod_curent = prev;
        }
        flux = bfs();
    }
    return flux_max;
}


void dfs(int nod){
    viz[nod] = true;

    for(int i = 1; i <= n; i++){
        if(graf[nod][i] && !viz[i]){
            dfs(i);
        }
    }
}

int main(){
    fin >> n >> m >> x;
    for(int i =  0; i < x; i ++){
        fin >> a >> b;
        graf[a][b + n] = 1;
        graf[b + n][a] = 0;
    }

    //legam un nod de start de toate nodurile din coloana stanga

    for(int i = 1; i <= n; i++){
        graf[0][i] = 1;
        graf[i][0] = 0;
    }

    //legam un nod de final de toate nodurile din coloana dreapta

    for(int i = 1; i <= m; i++){
        graf[i + n][n + m + 1] = 1;
        graf[n + m + 1][i + n] = 0;
    }


    fout << flux_maxim() << endl;

    //comparam graf-ul vechi cu cel rezultat dupa flux_max

    for(int i = 1; i <= n; i++)
        for(int j = n + 1; j <= n + m; j++)
            if(viz[i] && !viz[j] && graf2[i][j])
                fout << i << " " << j - n << endl;
}