Problem:
Score : 900 points

Problem Statement

You are given a sequence D_1, D_2, ..., D_N of length N.
The values of D_i are all distinct.
Does a tree with N vertices that satisfies the following conditions exist?

The vertices are numbered 1,2,..., N.

The edges are numbered 1,2,..., N-1, and Edge i connects Vertex u_i and v_i.

For each vertex i, the sum of the distances from i to the other vertices is D_i, assuming that the length of each edge is 1.

If such a tree exists, construct one such tree.

Constraints

2 \leq N \leq 100000

1 \leq D_i \leq 10^{12}

D_i are all distinct.

Input

Input is given from Standard Input in the following format:

N
D_1
D_2
:
D_N

Output

If a tree with n vertices that satisfies the conditions does not exist, print -1.

If a tree with n vertices that satisfies the conditions exist, print n-1 lines.
The i-th line should contain u_i and v_i with a space in between.
If there are multiple trees that satisfy the conditions, any such tree will be accepted.

Sample Input 1

7
10
15
13
18
11
14
19

Sample Output 1

1 2
1 3
1 5
3 4
5 6
6 7

The tree shown below satisfies the conditions.

Sample Input 2

2
1
2

Sample Output 2

-1

Sample Input 3

15
57
62
47
45
42
74
90
75
54
50
66
63
77
87
51

Sample Output 3

1 10
1 11
2 8
2 15
3 5
3 9
4 5
4 10
5 15
6 12
6 14
7 13
9 12
11 13

Solution in C++ (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#define biu (puts("-1"), exit(0))
using namespace std;
typedef long long ll;

template <typename Tp> inline void getint(Tp &num){
	register int ch, neg = 0;
	while(!isdigit(ch = getchar())) if(ch == '-') neg = 1;
	num = ch & 15;
	while(isdigit(ch = getchar())) num = num * 10 + (ch & 15);
	if(neg) num = -num;
}

int N, siz[100005], tope = 0;
struct disData {ll d; int id;} D[100005];
struct Edge {int np; Edge *nxt;} E[100005], *V[100005];

inline bool operator < (const disData &d1, const disData &d2) {return d1.d < d2.d;}
inline void addedge(const int &u, const int &v) {E[++tope].np = v, E[tope].nxt = V[u], V[u] = E + tope;}

int main(){
	getint(N);
	for(register int i = 1; i <= N; i++) getint(D[i].d), D[i].id = i, siz[i] = 1;
	sort(D + 1, D + N + 1);
	for(register int i = N; i > 1; i--){
		if((siz[i] << 1) >= N) biu;
		const ll d = D[i].d - N + (siz[i] << 1);
		const int fa = lower_bound(D + 1, D + N + 1, (disData){d, 0}) - D;
		if(D[fa].d != d) biu; siz[fa] += siz[i], addedge(fa, i);
	}
	for(register int i = 1; i <= N; i++)
		for(register Edge *ne = V[i]; ne; ne = ne->nxt) printf("%d %d\n", D[i].id, D[ne->np].id);
	return 0;
}