#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring> // pentru memset

using namespace std;

const int NMAX = 3005;

int capacitate[NMAX][NMAX];
int flux[NMAX][NMAX];
int vis[NMAX], p[NMAX];
vector<int> G[NMAX];

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

int bfs(int s, int d, int n_total) {
    for(int i = 0; i <= n_total; i++) {
        vis[i] = 0;
        p[i] = -1;
    }

    queue<int> q;
    q.push(s);
    vis[s] = 1;

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

        if(nod == d) continue;

        for(auto vecin : G[nod]) {
            if(!vis[vecin] && capacitate[nod][vecin] - flux[nod][vecin] > 0) {
                vis[vecin] = 1;
                q.push(vecin);
                p[vecin] = nod;
            }
        }
    }

    if(vis[d] == 0) {
        return 0;
    }

    int flow = 1e9;
    int curr = d;
    while(curr != s) {
        int prev = p[curr];
        flow = min(flow, capacitate[prev][curr] - flux[prev][curr]);
        curr = prev;
    }

    curr = d;
    while(curr != s) {
        int prev = p[curr];
        flux[prev][curr] += flow;
        flux[curr][prev] -= flow;
        curr = prev;
    }

    return flow;
}

int main() {
    int N, M, E;
    fin >> N >> M >> E;

    int noduri_necesare = N + M + 2;

    if (noduri_necesare >= NMAX) {
        fout << 0 << '\n';
        return 0;
    }

    int S = 0;
    int D = N + M + 1;

    for(int i = 1; i <= N; i++) {
        capacitate[S][i] = 1;
        G[S].push_back(i);
        G[i].push_back(S);
    }

    for(int i = 1; i <= M; i++) {
        int nod_dreapta = N + i;
        capacitate[nod_dreapta][D] = 1;
        G[nod_dreapta].push_back(D);
        G[D].push_back(nod_dreapta);
    }

    for(int i = 1; i <= E; i++) {
        int u, v;
        fin >> u >> v;
        int nod_dreapta = N + v;

        if(capacitate[u][nod_dreapta] == 0) {
            capacitate[u][nod_dreapta] = 1;
            G[u].push_back(nod_dreapta);
            G[nod_dreapta].push_back(u);
        }
    }

    int maxflow = 0;
    while(true) {
        int flow = bfs(S, D, D);
        if(flow == 0) {
            break;
        }
        maxflow += flow;
    }

    fout << maxflow << '\n';

    for(int i = 1; i <= N; i++) {
        for(auto vecin : G[i]) {
            if(vecin > N && vecin <= N + M) {
                if(flux[i][vecin] == 1) {
                    fout << i << " " << (vecin - N) << '\n';
                }
            }
        }
    }

    return 0;
}