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

ifstream cin("cuplaj.in");
ofstream cout("cuplaj.out");

int N, M, E;
int source = 0;
int sink;
vector<vector<int>> graph;
vector<vector<int>> cuplaj;
vector<bool> viz;

int dfs(int node, int flux_curent) {
    if (node == sink) return flux_curent;

    viz[node] = true;

    for (auto e : graph[node]) {
        if (!viz[e] && cuplaj[node][e] > 0) {
            int bottleneck = min(flux_curent, cuplaj[node][e]);
            int flux_pushed = dfs(e, bottleneck);

            if (flux_pushed > 0) {
                cuplaj[node][e] -= flux_pushed;
                cuplaj[e][node] += flux_pushed;
                return flux_pushed;
            }
        }
    }
    return 0;
}

int main() {
    cin >> N >> M >> E;
    graph.resize(N+M+2);
    cuplaj.resize(N+M+2);
    viz.resize(N+M+2);
    sink = N + M + 1;

    for (int i = 0; i <= N + M + 1; i++)
        cuplaj[i].resize(N+M+2);

    for (int i = 0; i < E; i++) {
        int u, v;
        cin >> u >> v;
        //legam muchiile
        graph[u].push_back(N + v);
        graph[N + v].push_back(u);

        // legam sursa de nodurile din L
        graph[source].push_back(u);
        graph[u].push_back(source);

        //legam nodurile din R de sink
        graph[N+v].push_back(sink);
        graph[sink].push_back(N+v);

        //adaugam capacitatile
        cuplaj[u][N + v] = 1;
        cuplaj[source][u] = 1;
        cuplaj[N + v][sink] = 1;
    }

    int cuplaj_maxim = 0;

    // ford fulkerson
    while (true) {
        viz.assign(N+M+2, false);
        int pushed = dfs(source, 1e9);
        if (!pushed)
            break;
        cuplaj_maxim += pushed;
    }

    cout << cuplaj_maxim << endl;
    // reconstruirea drumului

    for (int i = 1; i <= N; i++)
        for (auto e : graph[i]) {
            if (e > N && e < sink && cuplaj[i][e] == 0)
                cout << i << " " << e - N << "\n";
        }
    return 0;
}