#include <bits/stdc++.h>
using namespace std;
ifstream fin("cuplaj.in");
ofstream fout("cuplaj.out");
bool apare[10005];
int pre[10005],C[10005][10005],flux[10005][10005],n;
vector <int> G[10005];
queue <int> Q;
void bfs();


///ideea de rezolvare este sa adaugam o sursa si destinatie, conectam sursa de nodurile din prima multime prin muchii de capacitate egala cu 1
/// iar nodurile din a doua multime de destinatie cu muchii de capacitate tot 1
///muchiile din input se vor transforma in muchii intre cele 2 multimi tot de capacitate 1
///facem algoritmul pt fluxul maxim, iar muchiile saturate reprezinta conexiunile cautate din enunt
///sursa e nodul 0, destinatia nodul n+m+1, iar nodurile sunt de la 1 la n, respectiv de la n+1 la n+m

///complexitatea este O(M* (N+M) ) intrucat fluxul maxim e egal cu nr de muchii care trebuie adaugate??
int main()
{
    int i,m,fluxtotal=0,mini,x,y,c,nod,urm,s,d,e;
    fin>>n>>m>>e;
    s=0;
    d=n+m+1;
    for(i=1;i<=e;i++)
    {
        fin>>x>>y;
        y=n+y;
        C[s][x]=1;
        C[y][d]=1;

        G[s].push_back(x);
        G[x].push_back(s);

        G[d].push_back(y);
        G[y].push_back(d);

        C[x][y]=1;
        G[x].push_back(y);
        G[y].push_back(x);
    }


    while(1)
    {
        bfs();
        if(!apare[d]) break;
        for(i=0;i<G[d].size();i++)
            if (apare[G[d][i]] && C[G[d][i]][d]>flux[G[d][i]][d])
            {
                nod=G[d][i];
                urm=d;
                mini=C[nod][urm]-flux[nod][urm];
                while(nod>=0)
                {
                    mini=min(mini, C[nod][urm]-flux[nod][urm]);
                    urm=nod;
                    nod=pre[nod];
                }
                if(mini)
                {
                    nod=G[d][i];
                    urm=d;
                    while(nod>=0)
                    {
                        flux[nod][urm]+=mini;
                        flux[urm][nod]-=mini;
                        urm=nod;
                        nod=pre[nod];
                    }
                }
                fluxtotal+=mini;
            }
    }
    fout<<fluxtotal<<'\n';
    for(int i=1;i<=n;i++)
        for(int j=n+1;j<=n+m;j++)
            if(flux[i][j]==1)
                fout<<i<<" "<<j-n<<'\n';

    return 0;
}

void bfs()
{
    int nod,vecin,i;
    for(i=0;i<=2*n+1;i++) {apare[i]=0; pre[i]=0;}
    apare[0]=1;
    pre[0]=-1;
    Q.push(0);
    while(!Q.empty())
    {
        nod=Q.front();
        Q.pop();
        for(i=0;i<G[nod].size();i++)
        {
            vecin=G[nod][i];
            if (!apare[vecin] && C[nod][vecin]> flux[nod][vecin])
            {
                apare[vecin]=1;
                pre[vecin]=nod;
                Q.push(vecin);
            }
        }
    }
}