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

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

const int inf=1e9;
int n,m,e,nod1,nod2;

void flux_maxim(int S,int T,int nr_noduri,vector<vector<int>>&capacitate){


    
    vector<vector<int>>flux(nr_noduri+1,vector<int>(nr_noduri+1));
    vector<vector<int>>gr(nr_noduri+1);
    vector<int>tata(nr_noduri+1,0);
    queue<int>q;

    for(int i=1;i<=nr_noduri;i++){
        for(int j=1;j<=nr_noduri;j++){
            if(capacitate[i][j]){
                gr[i].push_back(j);
                gr[j].push_back(i);
            }
        }
    }


    int val=0;
    bool exista_flux=true;
    
    
    while(exista_flux){
    exista_flux=false;

    for(int i=1;i<=nr_noduri;i++){
        tata[i]=0;
    }
    tata[S]=S;
    q.push(S);

    while(!q.empty()){
        int nod_curent=q.front();
        q.pop();

        if(nod_curent==T){
            exista_flux=true;
            continue;
        }
        for(auto&vecin:gr[nod_curent]){

            if(!tata[vecin] && capacitate[nod_curent][vecin]-flux[nod_curent][vecin]>0){
                tata[vecin]=nod_curent;
                q.push(vecin);
            }
        }
    }

        for(auto& vecin:gr[T]){
             if(!tata[vecin]){
                continue;
             }
             tata[T]=vecin;
             int nod_curent=T;
             int minn=inf;

             while(nod_curent!=S){
                minn=min(minn,capacitate[tata[nod_curent]][nod_curent]-flux[tata[nod_curent]][nod_curent]);
                nod_curent=tata[nod_curent];
             }
             nod_curent=T;

             while(nod_curent!=S){
                flux[tata[nod_curent]][nod_curent]+=minn;
                flux[nod_curent][tata[nod_curent]]-=minn;
                nod_curent=tata[nod_curent];
             }
             val+=minn;
        }
    }        

   cout<<val<<'\n';
   for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(flux[i+1][j+n+1]==1){
                cout<<i<<" "<<j<<'\n';
            }
    }
   }

}
int main(){
   cin>>n>>m>>e;
   int nr_noduri=1+n+m+1;
   int S=1;
   int T=nr_noduri;

   vector<vector<int>>capacitate(nr_noduri+1,vector<int>(nr_noduri+1,0));
   
    for(int i=1;i<=e;i++){
        cin>>nod1>>nod2;
        capacitate[S][nod1+1]=1;
        capacitate[nod1+1][nod2+n+1]=1;
        capacitate[nod2+n+1][T]=1;
    }

    flux_maxim(S,T,nr_noduri,capacitate);
    return 0;
}