#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

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

// Reducem NMAX pentru a incapea in memorie daca folosim matrice
const int NMAX = 2005, inf = 1e9;
vector<int> g[NMAX];
int cap[NMAX][NMAX], n, m, e;

int bfs(int s, int t, int parents[]) {
    for (int i = 0; i < NMAX; i++) parents[i] = -1;
    parents[s] = -2;
    queue<pair<int, int>> q;
    q.push({s, inf});

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

        for (int v : g[u]) {
            if (parents[v] == -1 && cap[u][v] > 0) {
                parents[v] = u;
                int new_flow = min(flow, cap[u][v]);
                if (v == t) return new_flow;
                q.push({v, new_flow});
            }
        }
    }
    return 0;
}

int main() {
    if (!(fin >> n >> m >> e)) return 0;

    int S = 0, T = n + m + 1;

    for (int i = 0; i < e; i++) {
        int u, v;
        fin >> u >> v;
        v += n; // Deplasam indicii pentru multimea dreapta
        g[u].push_back(v);
        g[v].push_back(u);
        cap[u][v] = 1;
    }

    // Legam sursa de nodurile din stanga
    for (int i = 1; i <= n; i++) {
        g[S].push_back(i);
        g[i].push_back(S);
        cap[S][i] = 1;
    }

    // Legam nodurile din dreapta de destinatie
    for (int i = 1; i <= m; i++) {
        g[n + i].push_back(T);
        g[T].push_back(n + i);
        cap[n + i][T] = 1;
    }

    int max_match = 0, new_flow, parents[NMAX];
    while ((new_flow = bfs(S, T, parents))) {
        max_match += new_flow;
        int curr = T;
        while (curr != S) {
            int prev = parents[curr];
            cap[prev][curr] -= new_flow;
            cap[curr][prev] += new_flow;
            curr = prev;
        }
    }

    fout << max_match << "\n";
    
    // Afisarea perechilor: cautam muchiile u->v unde cap a devenit 0
    for (int u = 1; u <= n; u++) {
        for (int v : g[u]) {
            if (v > n && v <= n + m && cap[u][v] == 0) {
                fout << u << " " << v - n << "\n";
            }
        }
    }

    return 0;
}