#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

const int INF = 1 << 30;

ifstream f("cuplaj.in");
ofstream g("cuplaj.out");

class Graph {
private:
    int _n, _m;
    vector<vector<int>> _adjacentList; // liste de adiacenta

    vector<vector<pair<int, int> >> _adjacentListWithCosts;

public:
    Graph(int nodes, int edges) : _n(nodes), _m(edges) {}

    void setAdjacentList(const vector<vector<int>> &adjacentList);

    bool dfsCuplaj(int node, vector<int> &visited, vector<int> &left, vector<int> &right);

    vector<pair<int, int>> cuplaj();
};

void Graph::setAdjacentList(const vector<vector<int>> &adjacentList) {
    _adjacentList = adjacentList;
}

// DFS-ul acesta va cauta nodurile din prima multime care inca nu au pereche si o va forma
// sau nodurile care au pereche din prima multime, dar continua cu lant alternant care accepta o augmentare de o unitate de flux
// Functia returneaza true, daca s-a format pereche sau lant alternant, si false altfel.
bool Graph::dfsCuplaj(int node, vector<int> &visited, vector<int> &left, vector<int> &right) {

    if (visited[node])
        return false;

    visited[node] = 1;

    for (int i = 0; i < _adjacentList[node].size(); ++i)
        if (!right[_adjacentList[node][i]] || dfsCuplaj(right[_adjacentList[node][i]], visited, left, right)) {
            right[_adjacentList[node][i]] = node;
            left[node] = _adjacentList[node][i];
            return true;
        }

    return false;
}


vector<pair<int, int>> Graph::cuplaj() {
    vector<pair<int, int>> answer;

    vector<int> left(10001, 0), right(10001, 0);
    vector<int> visited(_n + 1, 0);
    bool ok;

    do {
        ok = false;
        for (int i = 0; i <= _n; ++i)
            visited[i] = 0;

        for (int i = 1; i <= _n; ++i)
            if (left[i] == 0 && dfsCuplaj(i, visited, left, right))
                ok = true;
    } while (ok == true);

    for (int i = 1; i <= _n; ++i)
        if (left[i] != 0)
            answer.push_back(make_pair(i, left[i]));

    return answer;
}


int main() {
    int n, m, e, x, y;
    f >> n >> m >> e;

    Graph grf(n, e);
    vector<vector<int>> gr(100001);

    for (int i = 0; i < e; ++i) {
        f >> x >> y;
        gr[x].push_back(y);
    }
    grf.setAdjacentList(gr);

    vector<pair<int, int>> answer = grf.cuplaj();

    g << answer.size() << '\n';
    for (int i = 0; i < answer.size(); ++i)
        g << answer[i].first << " " << answer[i].second << '\n';

    f.close();
    g.close();
    return 0;
}