using namespace std;
#include <fstream>
#include <vector>
#include <algorithm>
#include <string>
#include <queue>
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define Nmax 1000000

struct _node { int l, r; ll freq; } nodes[2 * Nmax];
class _queue
{
private:
	int Q1[Nmax], Q2[Nmax];
	int l1, r1, l2, r2;

public:
	_queue() : l1(0), r1(-1), l2(0), r2(-1) {}

	void init(const int n)
	{
		for (int i = 0; i < n; ++i) Q1[++r1] = i;
	}

	int getMin()
	{
		int ret;

		if (l1 > r1) ret = Q2[l2], ++l2;
		else if (l2 > r2) ret = Q1[l1], ++l1;
		else if (nodes[Q1[l1]].freq < nodes[Q2[l2]].freq)
		{
			ret = Q1[l1];
			++l1;
		}
		else
		{
			ret = Q2[l2];
			++l2;
		}

		return ret;
	}

	void push(int node)
	{
		Q2[++r2] = node;
	}

	int size()
	{
		return static_cast<int>(r1 - l1 + 1 + r2 - l2 + 1);
	}
} Q;

int n;
vector< int > lg;
vector< ll > codes;

void read();
void getCodes(int, ll, int);
void write();

int main()
{
	int k, a, b;

	read();

	k = n;
	for (Q.init(n); Q.size() > 1; )
	{
		++k;

		a = nodes[k].l = Q.getMin();
		b = nodes[k].r = Q.getMin();
		nodes[k].freq = nodes[a].freq + nodes[b].freq;

		Q.push(k);
	}

	codes.resize(n);
	lg.resize(n);

	getCodes(k, 0, 0);

	write();

    return 0;
}


void read()
{
	ifstream fin("huffman.in");

	fin >> n;
	for (int i = 0; i < n; ++i) fin >> nodes[i].freq, nodes[i].l = nodes[i].r = -1;

	fin.close();
}

void getCodes(int node, ll code, int l)
{
	if (nodes[node].l == -1) codes[node] = code, lg[node] = l;
	else
	{
		getCodes(nodes[node].l, code << 1, l + 1);
		getCodes(nodes[node].r, (code << 1) + 1, l + 1);
	}
}

void write()
{
	int i;
	ll lgCode;
	ofstream fout("huffman.out");

	for (lgCode = 0, i = 0; i < n; ++i)
		lgCode += 1LL * nodes[i].freq * lg[i];

	fout << lgCode << '\n';

	for (i = 0; i < n; ++i)
		fout << lg[i] << ' ' << codes[i] << '\n';

	fout.close();
}