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

void read(int &n, int &l, int &r, int &s, int &t, vector<vector<int> > &G,
          vector<vector<int> > &GT, vector<vector<int> > &cost,
          vector<vector<int> > &f) {
    ifstream fin("cuplaj.in");
    if (!fin.is_open()) {
        cout << "The file can't be opened!\n";
        exit(EXIT_FAILURE);
    }

    fin >> l >> r;
    n = l + r + 2;
    s = l + r + 1;
    t = l + r + 2;
    G.resize(n + 1);
    GT.resize(n + 1);
    cost.resize(n + 1, vector<int>(n + 1, 0));
    f.resize(n + 1, vector<int>(n + 1, 0));
    int E;
    vector<int> viz(n + 1, 0);
    fin >> E;
    for (int i = 0; i < E; ++i) {
        int x, y;
        fin >> x >> y;
        if (viz[x] == 0) {
            G[s].push_back(x);
            GT[x].push_back(s);
            cost[s][x] = 1;
            viz[x] = 1;
        }
        G[x].push_back(y + l);
        cost[x][y + l] = 1;
        GT[y + l].push_back(x);

        if (viz[y + l] == 0) {
            G[y + l].push_back(t);
            GT[t].push_back(y + l);
            viz[y + l] = 1;
            cost[y + l][t] = 1;
        }
    }

    /*for(int i = 1; i <= n; ++i) {
        cout << i << ':';
        for (vector<int>::iterator it = G[i].begin(); it != G[i].end(); ++it) {
            cout << *it << ' ';
        }
        cout << '\n';
    }
    */
    fin.close();
}

bool BFS(int &n, int &s, int &t, vector<vector<int> > &G, vector<vector<int> > &GT,
         vector<vector<int> > &cost, vector<vector<int> > &f, vector<int> &tata) {
    tata = vector<int>(n + 1, 0);
    vector<int> viz(n + 1, 0);
    queue<int> Q;
    //Edmonds-Karp
    Q.push(s);
    viz[s] = 1;
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        for (vector<int>::iterator it = G[u].begin(); it != G[u].end(); ++it) {
            int v = *it;
            if (viz[v] == 0 && cost[u][v] - f[u][v] > 0) {
                viz[v] = 1;
                tata[v] = u;
                Q.push(v);
                if (v == t)
                    return true;
            }
        }

        for (vector<int>::iterator it = GT[u].begin(); it != GT[u].end(); ++it) {
            int v = *it;
            if (viz[v] == 0 && f[v][u] > 0) {
                viz[v] = 1;
                tata[v] = -u;
                Q.push(v);
                if (v == t)
                    return true;
            }
        }
    }
    return false;
}

int main() {
    int n, l, r, s, t, flux = 0;
    vector<int> tata;
    vector<vector<int> > G, GT, cost, f;
    read(n, l, r, s, t, G, GT, cost, f);
    while(BFS(n, s, t, G, GT, cost, f, tata)) {
        int IP = 1;
        int x = t;
        while (tata[x]) {
            if (tata[x] >= 0) {
                f[tata[x]][x] += IP;
                x = tata[x];
            } else {
                f[x][-tata[x]] -= IP;
                x = -tata[x];
            }
        }
        flux += IP;
    }

    vector<pair<int, int> > Edge;
    for (int i = 1; i <= l; ++i) {
        for (vector<int>::iterator it = G[i].begin(); it != G[i].end(); ++it) {
            int j = *it;
            if (f[i][j] == 1) {
                Edge.push_back(make_pair(i, j - l));
            }
        }
    }
    ofstream fout("cuplaj.out");
    fout << Edge.size() << '\n';
    for (vector<pair<int, int> >::iterator it = Edge.begin(); it != Edge.end(); ++it) {
        fout << it->first << ' ' << it->second << '\n';
    }
    return 0;
}