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

using namespace std;

const int NMAX = 1e3; 
int capacitate[NMAX + 1][NMAX + 1];
int flux[NMAX + 1][NMAX + 1];
int vis[NMAX + 1], p[NMAX + 1];
vector<int> G[NMAX + 1];

int n, m, e;
int noduri;   
int src, dest;

int bfs(int s, int d);

int main() {
    ifstream reader("cuplaj.in");
    ofstream writer("cuplaj.out");
    reader >> n >> m >> e;

    noduri = n+m+2;
    src = 1;
    dest = noduri;

    for(int u = 1; u <= n; u++) {
        int u_flux = u + 1;
        capacitate[src][u_flux] = 1;
        G[src].push_back(u_flux);
        G[u_flux].push_back(src);
    }

    for(int v = 1; v <= m; v++) {
        int v_flux = n + 1 + v;
        capacitate[v_flux][dest] = 1;
        G[v_flux].push_back(dest);
        G[dest].push_back(v_flux);
    }

    for(int i = 1; i <= e; i++) {
        int u, v;
        reader >> u >> v;

        int u_flux = u+1;
        int v_flux = n+1+v;

        capacitate[u_flux][v_flux] = 1;
        G[u_flux].push_back(v_flux);
        G[v_flux].push_back(u_flux);
    }

    int maxflow = 0;
    while(true) {
        int f = bfs(src, dest);
        if(f == 0) 
            break;
        maxflow += f;
    }
    writer << maxflow << endl;

    for(int u = 1; u <= n; u++) {
        for(int i = 0; i < G[u+1].size(); i++) {
            int vf = G[u+1][i];
            if(vf >= n + 2 && vf <= n + m + 1 && flux[u+1][vf] == 1) {
                writer << u <<" "<< vf-(n + 1) << endl;
            }
        }
    }
    return 0;
}


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

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

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

    if(!vis[d])
        return 0;

    vector<int> path;
    int x = d;
    while(x != 0) {
        path.push_back(x);
        x = p[x];
    }
    reverse(path.begin(), path.end());

    int flow = 1e9;
    for(int i = 0; i < path.size() - 1; i++) {
        int a = path[i];
        int b = path[i + 1];
        flow = min(flow, capacitate[a][b] - flux[a][b]);
    }

    for(int i = 0; i < path.size() - 1; i++) {
        int a = path[i];
        int b = path[i + 1];
        flux[a][b] += flow;
        flux[b][a] -= flow;
    }

    return flow;
}