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

ifstream f("cuplaj.in");
ofstream g("cuplaj.out");

int n, m, e;
vector<vector<int>> adj; // adj[u] = lista vecinilor din R pentru nodul u din L
vector<int> matchL;      // matchL[u] = nodul din R cu care e cuplat u din L (-1 daca nu e cuplat)
vector<int> matchR;      // matchR[v] = nodul din L cu care e cuplat v din R (-1 daca nu e cuplat)
vector<bool> viz;        // vizitat in DFS-ul curent

// Incearca sa gaseasca un drum de augmentare pornind din nodul u din L
bool dfs(int u)
{
    for (int v : adj[u])
    {
        if (!viz[v])
        {
            viz[v] = true;

            // Daca v nu e cuplat sau putem recupla nodul cu care era cuplat v
            if (matchR[v] == -1 || dfs(matchR[v]))
            {
                matchL[u] = v;
                matchR[v] = u;
                return true;
            }
        }
    }
    return false;
}

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

    adj.resize(n + 1);
    matchL.assign(n + 1, -1);
    matchR.assign(m + 1, -1);
    viz.resize(m + 1);

    for (int i = 0; i < e; i++)
    {
        int u, v;
        f >> u >> v;
        adj[u].push_back(v);
    }

    // Algoritmul lui Kuhn (Hungarian Algorithm)
    int cuplaj = 0;
    bool found = true;

    // Repetam pana nu mai gasim drumuri de augmentare
    while (found)
    {
        found = false;
        for (int u = 1; u <= n; u++)
        {
            if (matchL[u] == -1)
            {
                // Resetam vizitarea pentru fiecare cautare
                fill(viz.begin(), viz.end(), false);
                if (dfs(u))
                {
                    cuplaj++;
                    found = true;
                }
            }
        }
    }

    // Afisam rezultatul
    g << cuplaj << "\n";
    for (int u = 1; u <= n; u++)
    {
        if (matchL[u] != -1)
        {
            g << u << " " << matchL[u] << "\n";
        }
    }

    return 0;
}