// Complexitate: O(n * m^2)

#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

int cap[20002][20002], n, m, e, max_flow, current_flow;
vector<int> vis, pred;
vector<vector<int>> adj;

// Parcurg graful prin BFS, cu conditia ca fluxul exuistent dintre
// doua noduri sa nu depaseasca capacitatea muchiei respective.
// De asemenea, pe langa faptul ca un anume nod este vizitat, retin
// si care este nodul din care am ajuns in acesta (predecesorul).
bool bfs()
{
    fill(vis.begin(), vis.end(), 0);
    fill(pred.begin(), pred.end(), 0);

    vis[0] = 1;
    pred[0] = 0;

    queue<int> q;
    q.push(0);

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

        q.pop();

        // Am ajuns in nodul destinatie.
        if (c == n + m + 1)
            return true;

        for (int i = 0; i < adj[c].size(); i++)
        {
            if (!vis[adj[c][i]] && 0 < cap[c][adj[c][i]])
            {
                q.push(adj[c][i]);
                pred[adj[c][i]] = c;
                vis[adj[c][i]] = 1;
            }
        }
    }
    
    return false;
}

int main()
{
    fin >> n >> m >> e;

    vis.resize(n + m + 2);
    pred.resize(n + m + 2);
    adj.resize(n + m + 2);

    for (int i = 1; i <= n; i++)
    {
        adj[0].push_back(i);
        adj[i].push_back(0);

        cap[0][i] = 1;
    }

    for (int i = n + 1; i <= n + m; i++)
    {
        adj[i].push_back(n + m + 1);
        adj[n + m + 1].push_back(i);

        cap[i][n + m + 1] = 1;
    }

    for (int i = 0; i < e; i++)
    {
        int u, v;
        fin >> u >> v;

        adj[u].push_back(n + v);
        adj[n + v].push_back(u);

        cap[u][n + v] = 1;
    }

    // Cat timp exista un drum intre sursa si destinatie.
    while (bfs())
    {
        // Iterez prin vecinii nodului destinatie.
        for (int i = 0; i < adj[n + m + 1].size(); i++)
        {
            // Daca un nod vecin cu nodul destinatie este vizitat,
            // inseamna ca acesta este unul dintre predecesorii nodului
            // destinatie. In acest caz, exista un drum intre sursa
            // si destinatie prin acest nod.
            if (vis[adj[n + m + 1][i]])
            {
                pred[n + m + 1] = adj[n + m + 1][i];
                
                current_flow = __INT_MAX__;

                // Determin care este limitarea de pe ruta
                // (muchia cu capacitate minima).
                for (int j = n + m + 1; j != 0; j = pred[j])
                {
                    current_flow = min(current_flow, cap[pred[j]][j]);
                }

                // Adun fluxul curent la fluxul de pe fiecare muchie
                // din lant si il scad pentru a obtine flux negativ
                // pe muchiile de intoarcere.
                for (int j = n + m + 1; j != 0; j = pred[j])
                {
                    cap[pred[j]][j] -= current_flow;
                    cap[j][pred[j]] += current_flow;
                }

                // Adun fluxul curent la fluxul maxim.
                max_flow += current_flow;
            }
        }
    }

    fout << max_flow << '\n';

    for (int i = 1; i <= n; i++)
        for (int j = 1; j < adj[i].size(); j++)
            if (!cap[i][adj[i][j]])
                fout << i << ' ' << adj[i][j] - n << '\n';

    // for (int i = 1; i <= n; i++)
    //     for (int j = 1; j <= m + 1; j++)
    //         if (flow[i][j + n] == 1 && flow[j + n][i] == 0)
    //             fout << i << ' ' << j << '\n';

    return 0;
}