#include <bits/stdc++.h>

using namespace std;


const int Nmax = 10001; 

int capacitate[Nmax+1][Nmax+1];
int flux[Nmax+1][Nmax+1];
int n, m, e;
vector<int> G[Nmax+1];
int vis[Nmax+1];
int p[Nmax+1];


int bfs(int s, int t) {
    for(int i=0;i<=n+m+1;++i) {
        p[i]=0;
        vis[i]=0;
    }
    
    queue<int> q;
    q.push(s);
    vis[s]=1;
    
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        
        if (u == t) 
        continue; 
        
        for(int i=0;i<G[u].size();++i) {
            int v=G[u][i];
            if(vis[v]==0 && capacitate[u][v]>flux[u][v]) {
                vis[v]=1;
                p[v]=u;
                if(v==t) {
                        int flow=1e9;
                        int curr=t;
                        while(curr!=s) {
                            int prev=p[curr];
                            flow=min(flow,capacitate[prev][curr]-flux[prev][curr]);
                            curr=prev;
                        }                   
                        curr=t;
                        while(curr != s) {
                            int prev = p[curr];
                            flux[prev][curr]+=flow;
                            flux[curr][prev]-=flow;
                            curr=prev;
                        }

                        return flow;
                        }
                q.push(v);
            }
        }
    }
    return 0;
}

int main() {
    ifstream f("cuplaj.in");
    ofstream g("cuplaj.out");
    
    f>>n>>m>>e;
    
    int S=0;
    int T=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) {
        capacitate[n+i][T] = 1;
        G[n+i].push_back(T);
        G[T].push_back(n+i);
    }
    
    for(int i=1;i<=e;++i) {
        int u,v;
        f>>u>>v;

        int N=n+v;
        
        capacitate[u][N] = 1;
        G[u].push_back(N);
        G[N].push_back(u);
    }
    
    int maxflow=0;
    int flow;
    while((flow=bfs(S, T))) {
        maxflow+=flow;
    }
    
    g<<maxflow<<"\n";
    
    for(int i=1;i<=n;++i) {
        for(int j=0;j<G[i].size();++j) {
            int neighbor = G[i][j];
            if(neighbor>n && neighbor<=n + m) {
                if(flux[i][neighbor]==1) {
                    g<<i<<" "<<(neighbor-n)<<"\n";
                }
            }
        }
    }
    
    return 0;
}