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

using namespace std;
ifstream fin("cuplaj.in");
ofstream fout("cuplaj.out");
vector<vector<int> > capacity;      
vector<vector<int> > adj_list;
vector<int>parent;
int n,m,e,t,s;

bool BFS()                  
{
    vector<bool> viz(t+1);
    queue<int> coada;
    coada.push(s);
    viz[s]=1;                                                //il facem vizitat
    parent[s]=-1;
    while(!coada.empty())
    {
        int u=coada.front();
        coada.pop();
        for(auto v:adj_list[u])
        {
            if(viz[v]==0 && capacity[u][v]!=0)              //daca e nevizitat si se mai poate trece prin muchie(mai are capacitate ramasa)
            {
                parent[v]=u;                                //construim vectorul de tati
                if(v==t)                                    //verificam daca am ajuns la nodul final
                    return 1;
                viz[v]=1;                                   //il facem vizitat
                coada.push(v);
            }
        }
    }
    return 0;
}
int EdmondsKarp()
{
    long maxFlow=0;
    while(BFS()==true)     //facem bfs cat timp mai exista drumuri de la start la final pe care sa le verificam pentru fluxul maxim
    {
        int u,v=t;
        int pathFlow=INT_MAX;
        while(v!=s)
        {
            u=parent[v];
            if(capacity[u][v]<pathFlow)
                pathFlow=capacity[u][v];                    //obtinem capacitatea minima
            v=parent[v];                                    //parcurgem drumul prin vectorul de tati (construit in bfs)
        }
        v=t;
        while(v!=s)
        {
            u=parent[v];
            capacity[u][v]-=pathFlow;                       //actualizam capacitatile
            capacity[v][u]+=pathFlow;
            v=parent[v];
        }
        maxFlow+=pathFlow;                                  //actualizam fluxul maxim
    }
    return maxFlow;
}

void afisare()
{
    fout<<EdmondsKarp()<<"\n";
    for(int i=1; i<=n; i++)
        for(int j=n+1;j<=n+m; j++)
        {
            if(capacity[j][i]==1)
                fout<<i<<" "<<j-n<<"\n";
        }
}

void citire()
{
    fin>>n>>m>>e;
    s=0;                                                //nodul de start 
    t=n+m+1;                                            //nodul final
    adj_list.resize(t+1);
    parent.resize(t+1);
    capacity.resize(t+1, vector<int>(t+1));              //capacitatea maxima a muchiei 
    for(int i=1;i<=e;i++)                               // creez lista de adiacenta a grafului fara nodul de start si final
    {
        int a,b;
        fin>>a>>b;
        adj_list[a].push_back(b+n);
        adj_list[b+n].push_back(a);
        capacity[a][b+n]=1;                                 //toate capacitatile sunt 1 
    }
    //facem muchii de la nodul de start la fiecare nod din stanga si de la fiecare nod din dreapta la nodul final
    for(int i=1;i<=n;++i)                                   //adaug nodul de start
    {
        adj_list[s].push_back(i);
        adj_list[i].push_back(s);
        capacity[s][i]=1;                                   //toate capacitatile sunt 1 
    }
    for(int i=n+1;i<=n+m;++i)                               //adaug nodul final
    {
        adj_list[i].push_back(t);
        adj_list[t].push_back(i);
        capacity[i][t]=1;                                   //toate capacitatile sunt 1 
    }
    afisare();
}

int main()
{
    citire();
    return 0;                                               //complexitatea este O(nm^2)
}