// #include <iostream>    // Librăria pentru fluxurile standard de intrare/ieșire
// #include <vector>      // Librăria pentru vectori (liste dinamice)
// #include <queue>       // Librăria pentru structura de date de tip coadă (folosită la BFS)
// #include <fstream>     // Librăria pentru lucrul cu fișiere

// using namespace std;   // Permite utilizarea funcțiilor standard fără prefixul std::

// const int MAXN = 10005; // Definim dimensiunea maximă pentru noduri conform restricțiilor
// const int INF = 1e9;    // Definim o valoare foarte mare pentru distanțe (infinit)

// ifstream fin("cuplaj.in");   // Deschidem fișierul de intrare
// ofstream fout("cuplaj.out"); // Deschidem fișierul de ieșire

// vector<int> adj[MAXN];      // Lista de adiacență pentru a stoca muchiile dintre mulțimile A și B
// int perecheA[MAXN];         // perecheA[u] stochează nodul din B cu care este cuplat u din A
// int perecheB[MAXN];         // perecheB[v] stochează nodul din A cu care este cuplat v din B
// int dist[MAXN];             // Stochează nivelul (stratul) fiecărui nod calculat de BFS
// int n, m, e;                // n - noduri în A, m - noduri în B, e - numărul de muchii

// // Funcția BFS: Împarte graful în straturi pentru a găsi cele mai scurte drumuri de creștere
// bool bfs() {
//     queue<int> q;           // Creăm o coadă pentru parcurgerea în lățime
//     for (int i = 1; i <= n; i++) { // Parcurgem toate nodurile din mulțimea A
//         if (perecheA[i] == 0) {    // Dacă nodul i este liber (necuplat)
//             dist[i] = 0;           // Începe un nou drum de creștere (nivelul 0)
//             q.push(i);             // Îl adăugăm în coadă pentru procesare
//         } else {
//             dist[i] = INF;         // Dacă e deja cuplat, îl marcam cu infinit (nevizitat)
//         }
//     }

//     dist[0] = INF; // Nodul 0 este un nod virtual care reprezintă "capătul" unui drum de creștere

//     while (!q.empty()) {           // Cât timp mai avem noduri în coadă
//         int u = q.front();         // Luăm primul nod din coadă
//         q.pop();                   // Îl eliminăm din coadă

//         if (dist[u] < dist[0]) {   // Dacă nu am depășit nivelul primului drum de creștere găsit
//             for (int v : adj[u]) { // Analizăm toți vecinii nodului u din mulțimea B
//                 // Verificăm dacă partenerul lui v (care e în A) nu a fost vizitat
//                 if (dist[perecheB[v]] == INF) {
//                     dist[perecheB[v]] = dist[u] + 1; // Setăm stratul următor
//                     q.push(perecheB[v]);             // Adăugăm partenerul în coadă
//                 }
//             }
//         }
//     }
    
//     // Returnează true dacă am reușit să ajungem la nodul virtual 0 (un nod liber din B)
//     return (dist[0] != INF);
// }

// // Funcția DFS: Caută drumuri de creștere pe straturile definite de BFS
// bool dfs(int u) {
//     if (u != 0) { // Dacă nodul curent nu este nodul virtual de final
//         for (int v : adj[u]) { // Parcurgem vecinii nodului u
//             // Verificăm dacă vecinul face parte din stratul imediat următor
//             if (dist[perecheB[v]] == dist[u] + 1) {
//                 if (dfs(perecheB[v])) { // Încercăm să găsim un drum de creștere recursiv
//                     perecheB[v] = u;    // Dacă s-a găsit, actualizăm cuplajul pentru v
//                     perecheA[u] = v;    // Actualizăm cuplajul pentru u
//                     return true;        // Confirmăm că drumul a fost găsit
//                 }
//             }
//         }
//         dist[u] = INF; // Dacă nu există drum prin u, îl marcăm pentru a nu-l mai vizita
//         return false;  // Nu am găsit drum de creștere prin acest nod
//     }
//     return true; // Am ajuns la nodul virtual 0, drumul de creștere este complet
// }

// int main() {
//     if (!(fin >> n >> m >> e)) return 0; // Citim dimensiunile și verificăm dacă s-a reușit

//     for (int i = 0; i < e; i++) { // Citim cele e muchii ale grafului
//         int u, v;                 // Variabile pentru nodurile ce formează muchia
//         fin >> u >> v;            // Citim nodul u din A și nodul v din B
//         adj[u].push_back(v);      // Adăugăm v în lista de adiacență a lui u
//     }

//     int cuplaj_maxim = 0;         // Variabilă pentru a număra câte perechi am format
    
//     // Rulăm algoritmul în faze: BFS construiește straturi, DFS caută drumuri în ele
//     while (bfs()) {               // Cât timp BFS găsește drumuri de creștere posibile
//         for (int i = 1; i <= n; i++) { // Pentru fiecare nod din mulțimea A
//             // Dacă nodul este liber și DFS reușește să îi găsească o pereche
//             if (perecheA[i] == 0 && dfs(i)) {
//                 cuplaj_maxim++;   // Incrementăm mărimea totală a cuplajului
//             }
//         }
//     }

//     fout << cuplaj_maxim << "\n"; // Afișăm numărul maxim de perechi formate
//     for (int i = 1; i <= n; i++) { // Parcurgem nodurile din prima mulțime
//         if (perecheA[i] != 0) {    // Dacă nodul i a fost cuplat
//             fout << i << " " << perecheA[i] << "\n"; // Afișăm perechea (A, B)
//         }
//     }

//     return 0; // Finalizăm programul
// }
// Copilot Rules:
// RULE: There shouldnt be any spaces in the code, except after commas.
// RULE: All variables in main should be declared globally, and can be used before they are defined.
// RULE: All open curly braces should be placed on the same line as the function or control structure they belong to, not on the line after.
#include <bits/stdc++.h>
#define N 10010
using namespace std;
ifstream fin("cuplaj.in");   //strudel
ofstream fout("cuplaj.out"); //cuplaj
int n,m,e,i,x,y,cnt,inf=1e9;
vector<int> v[N];
int pda[N],pdb[N],lvl[N];
queue<int> q;
bool bfs(){
    while(!q.empty()) q.pop();
    for(i=1;i<=n;i++){
        if(pdb[i]==0) lvl[i]=0,q.push(i);
        else lvl[i]=inf;
    }
    lvl[0]=inf;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(lvl[u]<lvl[0])
            for(auto vec:v[u]){
                if(lvl[pda[vec]]==inf){
                    lvl[pda[vec]]=lvl[u]+1;
                    q.push(pda[vec]);
                }
            }
    }
    return lvl[0]!=inf;
}
bool dfs(int nod){
    if(nod==0) return 1;
    for(auto vec:v[nod]){
        if(lvl[pda[vec]]==lvl[nod]+1&&dfs(pda[vec])==1){
            pda[vec]=nod,pdb[nod]=vec;
            return 1;
        }
    }
    lvl[nod]=inf;
    return 0;
}
int main()
{
    fin>>n>>m>>e;
    for(i=1;i<=e;i++){
        fin>>x>>y;
        v[x].push_back(y);
    }
    while(bfs()==1){
        for(i=1;i<=n;i++){
            if(pdb[i]==0&&dfs(i)==1){
                cnt++;
                break;
            }
        }
    }
    fout<<cnt<<'\n';
    for(i=1;i<=n;i++)
        if(pdb[i]!=0) fout<<i<<" "<<pdb[i]<<'\n';
    return 0;
}