#include<fstream>

#include<vector>

#include<queue>



using namespace std;



ifstream fin( "harta.in" ); ofstream fout( "harta.out" );



typedef vector< int > graf;



const int nmax = 2 + 2 * 100;

int S, D;

int t[ nmax + 1 ];

int f[ nmax + 1 ][ nmax + 1 ], c[ nmax + 1 ][ nmax + 1 ];

graf g[ nmax + 1 ];



inline int min2( int a, int b ) {

    return ( a < b ? a : b );

}

bool bfs() {

    queue< int > q;

    for( int i = S; i <= D; ++ i ) {

        t[ i ] = -1;

    }



    q.push( S );

    t[ S ] = 0;

    while ( !q.empty() ) {

        int x = q.front();

        q.pop();



        for( graf::iterator it = g[ x ].begin(); it != g[ x ].end(); ++ it ) {

            if ( t[ *it ] == -1 && f[ x ][ *it ] < c[ x ][ *it ] ) {

                t[ *it ] = x;

                q.push( *it );

            }

        }

    }



    return ( t[ D ] != -1 );

}

int main() {

    int n, ans;

    fin >> n;



    S = 1; D = 2 * n + 2;

    ans = 0;

    for( int i = 1; i <= n; ++ i ) {

        int x, y;

        fin >> x >> y;

        c[ S ][ i + 1 ] = x;

        g[ S ].push_back( i + 1 );

        g[ i + 1 ].push_back( S );



        c[ i + n + 1 ][ D ] = y;

        g[ i + n + 1 ].push_back( D );

        g[ D ].push_back( i + n + 1 );

        ans += x;

    }

    for( int i = 1; i <= n; ++ i ) {

        for( int j = n + 1; j <= n + n; ++ j ) {

            if ( i != j - n ) {

                g[ i + 1 ].push_back( j + 1 );

                g[ j + 1 ].push_back( i + 1 );

                c[ i + 1 ][ j + 1 ] = 1;

            }

        }

    }



    while ( bfs() ) {

        for( graf::iterator it = g[ D ].begin(); it != g[ D ].end(); ++ it ) {

            if ( f[ *it ][ D ] < c[ *it ][ D ] && t[ *it ] != -1 ) {

                int val = c[ *it ][ D ] - f[ *it ][ D ];

                for( int nod = *it; nod != S; nod = t[ nod ] ) {

                    val = min2( val, c[ t[ nod ] ][ nod ] - f[ t[ nod ] ][ nod ] );

                }



                f[ *it ][ D ] += val;

                f[ D ][ *it ] -= val;

                for( int nod = *it; nod != S; nod = t[ nod ] ) {

                    f[ t[ nod ] ][ nod ] += val;

                    f[ nod ][ t[ nod ] ] -= val;

                }

            }

        }

    }



    fout << ans << "\n";

    for( int i = 1; i <= n; ++ i ) {

        for( int j = 1; j <= n; ++ j ) {

            if ( f[ i + 1 ][ j + n + 1 ] == 1 ) {

                fout << i << " " << j << "\n";

            }

        }

    }

    fin.close();

    fout.close();

    return 0;

}