#include <bits/stdc++.h>
#include <fstream>
#include <limits>
using namespace std;

ifstream fin("harta.in");
ofstream fout("harta.out");
vector<vector<int>> graph;
int capacitate[2005][2005], tata[2005], n, s, sink;

bool bfs()
{
    queue<int> coada;
    vector<bool> viz(n * 2 + 2, false);
    coada.push(s);
    viz[s] = true;
    tata[s] = -1;
    while (!coada.empty())
    {
        int node = coada.front();
        coada.pop();
        for (auto neighbour : graph[node])
        {
            if (!viz[neighbour] && capacitate[node][neighbour] != 0)
            {
                tata[neighbour] = node;
                if (neighbour == sink)
                {
                    return true;
                }
                viz[neighbour] = true;
                coada.push(neighbour);
            }
        }
    }
    return false;
}

int maximumFlowEdmondsKarp()
{
    int max = 0;
    while (bfs())
    {
        int drumuriCareIntra, drumuriCarePleaca = sink, flow = numeric_limits<int>::max();
        while (drumuriCarePleaca != s)
        {
            drumuriCareIntra = tata[drumuriCarePleaca];

            if (capacitate[drumuriCareIntra][drumuriCarePleaca] < flow)
                flow = capacitate[drumuriCareIntra][drumuriCarePleaca];

            drumuriCarePleaca = drumuriCareIntra;
        }

        drumuriCarePleaca = sink;
        while (drumuriCarePleaca != s)
        {
            drumuriCareIntra = tata[drumuriCarePleaca];
            capacitate[drumuriCareIntra][drumuriCarePleaca] -= flow;
            capacitate[drumuriCarePleaca][drumuriCareIntra] += flow;
            drumuriCarePleaca = drumuriCareIntra;
        }

        max += flow;
    }

    return max;
}

int main()
{
    int drumuriCarePleaca, drumuriCareIntra;
    fin >> n;
    sink = n * 2 + 1;
    graph.resize(sink + 1);

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (i != j)
            {
                graph[i].push_back(j + n);
                graph[j + n].push_back(i);
                capacitate[i][j + n] = 1;
            }
        }
        fin >> drumuriCarePleaca >> drumuriCareIntra;
        graph[s].push_back(i);
        graph[i].push_back(s);
        capacitate[s][i] = drumuriCarePleaca;
        graph[sink].push_back(i + n);
        graph[i + n].push_back(sink);
        capacitate[i + n][sink] = drumuriCareIntra;
    }

    fout << maximumFlowEdmondsKarp() << endl;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            if (capacitate[j + n][i] == 1)
                fout << i << " " << j << endl;
        }
    }

    return 0;
}