#include<fstream>
#include<set>

using namespace std;

#define f first
#define s second
#define mp make_pair

#define Nmax 1000100

struct {

    long long val;
    int fiu[3];
} G[Nmax * 2];

set<pair<long long, long long> > Heap;
long long B[Nmax], lg[Nmax], rez;
int N;

void read_data() {

    ifstream f("huffman.in");
    int i;

    f>>N;
    for(i=1; i<=N; i++) {
        f>>G[i].val;
        Heap.insert(mp(G[i].val, i));
    }
    f.close();
}

void DF(int poz, long long cod, long long nivel) {

    // fiind arbore strict e clar ca daca are un fiu il va avea si pe cel de-al doilea
    if(G[poz].fiu[1]) {
        DF(G[poz].fiu[1], cod*2, nivel+1);
        DF(G[poz].fiu[2], cod*2+1, nivel+1);
        return;
    }
    lg[poz] = nivel;
    B[poz] = cod;
    // adunam in rez suma costurilor nodurilor interne
    rez = (rez + lg[poz] * G[poz].val);
}

void solve() {

    int M, i, cost, nod;
    set<pair<long long, long long> >:: iterator it;

    M = N;
    // cand in Heap ramane o singura valoare inseamna ca s-au adunat toate valorile
    while(Heap.size() != 1) {
        ++M;
        // unim cele mai mici 2 noduri existente in Heap
        for(i=1; i<=2; ++i) {
            it = Heap.begin();
            cost = it->f;
            nod = it->s;
            Heap.erase(it);
            G[M].val += cost;
            G[M].fiu[i] = nod;
        }
        /* introducem in Heap noul nod creat care are ca fii cele 2 noduri de cost minim si
        ca valoare suma valorilor celor 2 noduri*/
        Heap.insert(mp(G[M].val, M));
    }
    DF(M, 0, 0);
}

void print_rez() {

    int i;
    ofstream g("huffman.out");
    g<<rez<<"\n";
    for(i=1; i<=N; ++i)
        g<<lg[i]<<" "<<B[i]<<"\n";
    g.close();
}

int main() {

    read_data();
    solve();
    print_rez();

    return 0;
}