#include <bits/stdc++.h>

using namespace std ;

class MaximalMatching {
public :
        MaximalMatching () {}
        MaximalMatching (vector< pair <int, int> > &edges, int st, int dr) {
            lftNodes = st ; 
            rgtNodes = dr ;
            gr.resize (st + 1) ; 
            lft.resize (dr + 1) ;
            rgt.resize (st + 1) ;
            viz.resize (st + 1, false) ;
            for (auto &x : edges) {
                gr [x.first].push_back (x.second) ;
                assert (isBetween (1, x.first, st)) ; 
                assert (isBetween (1, x.second, dr)) ;
            }
        }
        vector < pair <int, int> > Solve () {
            return _MaximalMatchinAlgorithm () ;
        }

private :
        int lftNodes, rgtNodes ;
        vector < vector <int> > gr;
        vector <bool> viz ; 
        vector <int> lft ; 
        vector <int> rgt ; 
        bool isBetween (int a, int b, int c) {
            return b >= a and b <= c ; 
        }
        bool _Match (int node) {
            if (viz [node]) return false ;
            viz [node] = 1 ; 
            for (auto &x : gr [node]) {
                if (lft [x] == 0) {
                    lft [x] = node ; 
                    rgt [node] = x ; 
                    return true ;
                }
            }
            for (auto &x : gr [node]) {
                if (_Match(lft [x])) {
                    lft [x] = node ; 
                    rgt [node] = x ; 
                    return true ;
                }
            }
            return false ;
        }
        vector < pair <int, int> > _MaximalMatchinAlgorithm () {
            bool ok ;
            do {
                ok = false ; 
                fill (viz.begin(), viz.end(), false) ;
                for (int i = 1 ; i <= lftNodes ; ++ i) {
                    if (rgt [i] == 0) {
                        ok |= _Match (i) ; 
                    }
                }
            } while (ok) ;
            vector < pair <int, int> > solution ; 
            for (int i = 1 ; i <= lftNodes ; ++ i) {
                if (rgt [i]) {
                    solution.push_back ({i, rgt [i]}) ;
                }
            }
            return solution ; 
        }
};

int main () {
    ifstream fin ("cuplaj.in") ; 
    ofstream fout ("cuplaj.out") ;
    int st, dr, m ; 
    fin >> st >> dr >> m ; 
    vector < pair <int, int> > edg ;
    while (m --) {
        int x, y ; 
        fin >> x >> y ; 
        edg.push_back ({x, y}) ;
    }
    MaximalMatching *Solve = new MaximalMatching (edg, st, dr) ;
    auto solution = Solve -> Solve () ;
    fout << solution.size() << '\n' ;
    for (auto &x : solution) {
        fout << x.first << ' ' << x.second << '\n' ; 
    }
    return 0 ; 
}