#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <chrono>
#include <fstream>
using namespace std;
using namespace std::chrono;

struct edge{
    int n1, n2, cap, pos;
};
vector<vector<int>> adjList;
vector<edge> edges;
vector<bool> visited;
vector<int> parent;
int n,m,e, nrN;
int source,dest;
void addEdge(int x, int y){
    int dim = (int)edges.size();

    adjList[x].push_back(dim);
    adjList[y].push_back(dim+1);

    edges.push_back({x,y,1,dim+1});
    edges.push_back({y,x,0, dim});
}


bool BFS()
{
    visited.clear();
    parent.clear();

    visited.resize(nrN, false);
    parent.resize(nrN);

    queue<int> q;
    visited[source] = true;

    q.push(source);
    while(!q.empty()) {

        int pNode = q.front(); //nodul parinte
        q.pop();
        if(pNode != dest) {
            // el e pozitia din lista de muchii a nodului parinte
            for (int el: adjList[pNode]) {
                edge cEdge = edges[el];
                if (!visited[cEdge.n2] && cEdge.cap != 0) {
                    parent[cEdge.n2] = el;
                    //adaugam urmatorul nod ce urmeaza sa fie vizitat
                    q.push(cEdge.n2);
                    visited[cEdge.n2] = true;
                }
            }
        }
    }
    return visited[dest];
}



int main() {
    auto start = high_resolution_clock::now();


ifstream in("cuplaj.in");
ofstream out("cuplaj.out");
    in >> n >> m >> e;

    nrN = n + m + 2;
    source = 0;
    dest = n + m + 1;
    adjList.resize(nrN);
    while(e--)
    {
        int x, y;
        in >> x >> y;
        addEdge(x,y + n);

    }
    for(int i = 1; i <= n; ++i)
    {
        addEdge(0,i);
    }
    for(int j = n + 1; j <= n + m; ++j)
    {
        addEdge(j, dest);
    }
    int mxFlow = 0;
    while(BFS()) {
        for (int el: adjList[dest]) {
            if (visited[edges[el].n2] and edges[edges[el].pos].cap != 0) {
                edge cEdge = edges[el];
                parent[dest] = cEdge.pos;
                int mnCap = 999999999;
                int cNode = dest;
                while (cNode != source) {
                    mnCap = min(mnCap, edges[parent[cNode]].cap);
                    cNode = edges[parent[cNode]].n1;
                }
                cNode = dest;
                while (cNode != source){
                    edges[parent[cNode]].cap -= mnCap;
                    edges[edges[parent[cNode]].pos].cap += mnCap;
                    cNode = edges[parent[cNode]].n1;
                }
                mxFlow += mnCap;
            }
        }
    }
    out<<mxFlow<<endl;
    for(auto edg:edges){
        if(edg.n1 < edg.n2 and edg.n1 != source and edg.n2!= dest and edg.cap == 0)
            out<<edg.n1<<" "<<edg.n2 - n<<endl;
    }
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop - start);
    cout << "Durata: " << duration.count();
    return 0;
}