#include <fstream>
#include <queue>

using namespace std;

const int NMAX = 100;

vector<int> graf[1 + 2 * NMAX + 1];

bool lantGasit;

queue<int> q;

int tata[1 + 2 * NMAX + 1];

int capacitate[1 + 2 * NMAX + 1][1 + 2 * NMAX + 1];

void bfs(int n)
{
    lantGasit = false;
    for (int i = 0; i <= 2 * n + 1; ++i)
        tata[i] = -1;

    tata[0] = 0;
    q.emplace(0);

    while (!q.empty())
    {
        int nod = q.front();
        q.pop();

        for (int i = 0; i < graf[nod].size(); ++i)
        {
            int vecin = graf[nod][i];

            if (tata[vecin] == -1 && capacitate[nod][vecin] > 0)
            {
                if (vecin != 2 * n + 1)
                {
                    tata[vecin] = nod;
                    q.emplace(vecin);
                }
                else
                {
                    lantGasit = true;
                }
            }
        }
    }
}

int main()
{
    ifstream in("harta.in");
    ofstream out("harta.out");

    ios_base::sync_with_stdio(false);
    in.tie(nullptr);
    out.tie(nullptr);

    int n;
    in >> n;

    for (int i = 1; i <= n; ++i)
        in >> capacitate[0][i] >> capacitate[n + i][2 * n + 1];

    for (int i = 1; i <= n; ++i)
        for (int j = n + 1; j <= 2 * n; ++j)
            if (n + i != j)
                capacitate[i][j] = 1;

    for (int i = 1; i <= n; ++i)
    {
        graf[0].emplace_back(i);
        graf[i].emplace_back(0);
    }
    for (int i = n + 1; i <= 2 * n; ++i)
    {
        graf[i].emplace_back(2 * n + 1);
        graf[2 * n + 1].emplace_back(i);
    }

    for (int i = 1; i <= n; ++i)
    {
        for (int j = n + 1; j <= 2 * n; ++j)
        {
            if (n + i != j)
            {
                graf[i].emplace_back(j);
                graf[j].emplace_back(i);
            }
        }
    }

    int fluxMaxim = 0;

    while (true)
    {
        bfs(n);

        if (!lantGasit)
            break;

        for (int i = 0; i < graf[2 * n + 1].size(); ++i)
        {
            int vecin = graf[2 * n + 1][i];

            int capMinima = 1e9;
            tata[2 * n + 1] = vecin;
            for (int nodCrt = 2 * n + 1; tata[nodCrt] != nodCrt; nodCrt = tata[nodCrt])
                capMinima = min(capMinima, capacitate[tata[nodCrt]][nodCrt]);

            for (int nodCrt = 2 * n + 1; tata[nodCrt] != nodCrt; nodCrt = tata[nodCrt])
            {
                capacitate[tata[nodCrt]][nodCrt] -= capMinima;
                capacitate[nodCrt][tata[nodCrt]] += capMinima;
            }

            fluxMaxim += capMinima;
        }
    }

    out << fluxMaxim << '\n';

    for (int i = 1; i <= n; ++i)
        for (int j = n + 1; j <= 2 * n; ++j)
            if (n + i != j && capacitate[i][j] == 0)
                out << i << ' ' << j - n << '\n';

    in.close();
    out.close();

    return 0;
}