#include <bits/stdc++.h>
using namespace std;

const int NMAX = 10000;

int cap[NMAX + 1][NMAX + 1];
int flowEdge[NMAX + 1][NMAX + 1];
int used[NMAX + 1], tata[NMAX + 1];
vector<int> adj[NMAX + 1];
int nrNoduri;

int cautaDrum(int start, int finish)
{
    for (int i = 1; i <= nrNoduri; i++)
    {
        used[i] = 0;
        tata[i] = 0;
    }

    queue<int> q;
    q.push(start);
    used[start] = 1;

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

        for (auto vecin : adj[nod])
        {
            if (!used[vecin] && cap[nod][vecin] - flowEdge[nod][vecin] > 0)
            {
                used[vecin] = 1;
                tata[vecin] = nod;
                q.push(vecin);
            }
        }
    }

    if (!used[finish])
    {
        return 0;
    }

    int extra = (int)1e9;
    int x = finish;
    while (x != start)
    {
        int par = tata[x];
        extra = min(extra, cap[par][x] - flowEdge[par][x]);
        x = par;
    }

    x = finish;
    while (x != start)
    {
        int par = tata[x];
        flowEdge[par][x] += extra;
        flowEdge[x][par] -= extra;
        x = par;
    }

    return extra;
}

void puneMuchie(int x, int y, int c)
{
    cap[x][y] = c;
    adj[x].push_back(y);
    adj[y].push_back(x);
}

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

    int N, M, E;
    fin >> N >> M >> E;

    int S = N + M + 1;
    int D = N + M + 2;
    nrNoduri = D;

    for (int i = 1; i <= E; i++)
    {
        int u, v;
        fin >> u >> v;
        int nodStanga = u;
        int nodDreapta = N + v;
        puneMuchie(nodStanga, nodDreapta, 1);
    }

    for (int i = 1; i <= N; i++)
    {
        puneMuchie(S, i, 1);
    }

    for (int i = 1; i <= M; i++)
    {
        puneMuchie(N + i, D, 1);
    }

    int maxFlow = 0;
    while (true)
    {
        int f = cautaDrum(S, D);
        if (f == 0) break;
        maxFlow += f;
    }

    fout << maxFlow << '\n';

    for (int i = 1; i <= N; i++)
    {
        for (auto vecin : adj[i])
        {
            if (vecin > N && vecin <= N + M)
            {
                if (flowEdge[i][vecin] == 1)
                {
                    fout << i << " " << (vecin - N) << '\n';
                }
            }
        }
    }

    return 0;
}