#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
using namespace std;
ifstream in("cuplaj.in");
ofstream out("cuplaj.out");

#define inf 1e9

vector<int> Tata;
vector<bool> Visited;

bool Find_BFS(int nod, int dest, auto &vecini_rezid, auto& cap_rezid) {

    Visited.assign(vecini_rezid.size(), false);
    //Tata.assign(vecini.size(), -1);
    queue<int> Q;

    Visited[nod] = true;
    Q.push(nod);

    while (!Q.empty()) {
        nod = Q.front();
        Q.pop();

        for (int v : vecini_rezid[nod]) {
            if (Visited[v]) continue;
            if (cap_rezid[nod][v]  <= 0) continue;

            Tata[v] = nod;
            Visited[v] = true;
            Q.push(v);

            if (v == dest)
                return true;
        }

    }
    return false;
}
int Min_Cap_Lant(int sursa, int dest, auto& cap_rezid) {
    int c = dest, cap_min = inf;
    while (c != sursa) {
        int tc = Tata[c];
        cap_min = min(cap_min, cap_rezid[tc][c] );
        c = tc;
    }

    return cap_min;
}
void Upd_Flux_Lant(int sursa, int dest, int cap_min, auto& cap_rezid) {
    int c = dest;

    while (c != sursa) {
        int tc = Tata[c];
        cap_rezid[tc][c] -= cap_min; //trimit flux -> scade capac reziduala
        cap_rezid[c][tc] += cap_min;
        c = tc;
    }
}

int main()
{
    int m1, m2, m;
    in >> m1 >> m2 >> m;

    int n = m1 + m2 + 2;

    vector<vector<int>> vecini_rezid;
    vector<vector<int>> capac_rezid;
    Tata.assign(n, 0);
    vecini_rezid = vector<vector<int>> (n);
    capac_rezid = vector<vector<int>> (n, vector<int> (n, 0));

    for (int i = 0; i < m; i++) {
        int x, y;
        in >> x >> y;

        capac_rezid[x][m1 + y] = 1;
        vecini_rezid[x].push_back(m1 + y);
        vecini_rezid[m1 + y].push_back(x);
    }

    for (int i = 1; i <= m1; i++) {
        capac_rezid[0][i] = 1;
        vecini_rezid[0].push_back(i);
        vecini_rezid[i].push_back(0);
    }

    for (int i = m1 + 1; i <= m1 + m2; i++) {
        capac_rezid[i][n - 1] = 1;
        vecini_rezid[n - 1].push_back(i);
        vecini_rezid[i].push_back(n - 1);
    }

    /*
        Cat timp bfs-ul din surs in destinatie gaseste un drum
        Determinam capacitatea minima (vectorul de tati) -> min
        Pe acelasi drum modificam fluxul cu min
    */
    int sursa = 0, dest = n - 1, flux_max = 0;

    while (Find_BFS(sursa, dest, vecini_rezid,capac_rezid)) {
        int cap_min = Min_Cap_Lant(sursa, dest, capac_rezid);
        Upd_Flux_Lant(sursa, dest, cap_min, capac_rezid);

        flux_max += cap_min;
    }
    out << flux_max << "\n";

    for (int i = 1; i <= m1; i++) {
        for (int j : vecini_rezid[i]) {
            if (j == 0) continue;
            if (capac_rezid[j][i] == 1) {
                out << i << " " << j - m1 << "\n";
            }
        }
    }
    return 0;
}