#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string>
using namespace std;
ifstream f("cuplaj.in");
ofstream g("cuplaj.out");
vector<int> vizitat;

vector<int> tata;
vector<vector<int>> muchii_indice; 


struct muchie
{
    int x, y, capacitate, poz;
};

vector<muchie> muchii;

int n, m, sursa, dest, l, r;

int bfs(){
    tata.clear();
    tata.resize(n);
    fill(vizitat.begin(), vizitat.end(), 0);
    queue<int> q;
    q.push(sursa);
    vizitat[sursa] = 1;

    while(!q.empty()){
        int nod = q.front();
        q.pop();
        if(nod == dest)
            continue;
        for(int i : muchii_indice[nod]){
            muchie m_curent = muchii[i];
            if(!vizitat[m_curent.y] and m_curent.capacitate != 0){
                vizitat[m_curent.y] = 1;
                tata[m_curent.y] = i;
                q.push(m_curent.y);
            }
        }
    }
    return vizitat[dest];
}

int flux_Maxim(){
    int maxFlux = 0;
    
    while(bfs()){
        for(auto i:muchii_indice[dest]){
            if(vizitat[muchii[i].y] and muchii[muchii[i].poz].capacitate != 0){
              
                int flux = 1e9;
                muchie m_curent = muchii[i];
                tata[dest] = m_curent.poz;
                int nod = dest;
                while(nod != sursa){
                    flux = min(flux, muchii[tata[nod]].capacitate);
                    nod = muchii[tata[nod]].x;
                }
                nod = dest;
                while(nod != sursa){
                  
                    muchii[tata[nod]].capacitate -= flux;
                    muchii[muchii[tata[nod]].poz].capacitate += flux;
                    nod = muchii[tata[nod]].x;
                }
              
                maxFlux += flux;
            }
        }
    }

    return maxFlux;
}

int main() {

    f>>l>>r>>m;
    n = l + r + 2;
    sursa = 0;
    dest = n - 1;
    vizitat.resize(n);
    tata.resize(n); 
    muchii_indice.resize(n); 

    for(int i = 1; i <= m; i++){
        int x, y;
        f>>x>>y;
        muchii.push_back({x, y + l, 1, 2 * i - 1});
        muchii.push_back({y + l, x, 0, 2 * i - 2});
        muchii_indice[y + l].push_back(2 * i - 1);
        muchii_indice[x].push_back(2 * i - 2);
    }


    int dimensiune_muchii = int (muchii.size());
    for(int i = 1; i <= l; i++){
      
        dimensiune_muchii += 2;
        muchii.push_back({sursa, i, 1, dimensiune_muchii - 1});
        muchii_indice[i].push_back(dimensiune_muchii - 1);
        muchii.push_back({i, sursa, 0, dimensiune_muchii - 2});
        muchii_indice[sursa].push_back(dimensiune_muchii - 2);
    }

    for(int i = l + 1; i < n - 1; i++){
   
        dimensiune_muchii += 2;
        muchii.push_back({i, dest, 1, dimensiune_muchii - 1});
        muchii_indice[dest].push_back(dimensiune_muchii - 1);
        muchii.push_back({dest, i, 0, dimensiune_muchii - 2});
        muchii_indice[i].push_back(dimensiune_muchii - 2);

    }
    
    g<<flux_Maxim()<<"\n";



    for(auto & i : muchii){
        if(i.capacitate == 0 and i.x != sursa and i.y != dest and i.x < i.y){
            g<<i.x<<" "<<i.y - l<<"\n";
        }
    }

    return 0;
}