#include <iostream>
#include <vector>
#include <fstream>
#include <queue>
#include <climits>
using namespace std;

const int INF = INT_MAX;

vector<vector<int>> capacity;
vector<vector<int>> adj;

bool bfs(int source, int sink, vector<int> &parent)
{
    int n = parent.size();
    fill(parent.begin(), parent.end(), -1);
    parent[source] = source;

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

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

        for (int v : adj[u])
        {
            if (parent[v] == -1 && capacity[u][v] > 0)
            {
                parent[v] = u;
                if (v == sink)
                    return true;
                q.push(v);
            }
        }
    }

    return false;
}

int maxFlow(int source, int sink, int nodes)
{
    vector<int> parent(nodes);
    int max_flow = 0;

    while (bfs(source, sink, parent))
    {
        max_flow++;

        int v = sink;
        while (v != source)
        {
            int u = parent[v];
            capacity[u][v]--;
            capacity[v][u]++;
            v = u;
        }
    }

    return max_flow;
}

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

    int n, m, e;
    fin >> n >> m >> e;

    int source = 0;
    int sink = n + m + 1;
    int nodes = n + m + 2;

    capacity.assign(nodes, vector<int>(nodes, 0));
    adj.resize(nodes);

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

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

    for (int i = 0; i < e; i++)
    {
        int u, v;
        fin >> u >> v;
        int right_node = n + v;
        capacity[u][right_node] = 1;
        adj[u].push_back(right_node);
        adj[right_node].push_back(u);
    }

    int matching = maxFlow(source, sink, nodes);

    fout << matching << "\n";

    for (int u = 1; u <= n; u++)
    {
        for (int v = 1; v <= m; v++)
        {
            int right_node = n + v;
            if (capacity[right_node][u] == 1)
            {
                fout << u << " " << v << "\n";
            }
        }
    }

    fin.close();
    fout.close();

    return 0;
}