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++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
typedef long long LL;
const int N=1e6;
int n,dx=0,fa[N+10],sz[N+10];
LL d[N+10],sum=0;
map <LL,int> mp;
vector <int> son[N+10];
void Dfs(int x) {
    sum+=dx;
    for (int i=0;i<(int)son[x].size();i++) {
        int kx=son[x][i];
        dx++;
        Dfs(kx);
        dx--;
    }
}
void Print(int x) {
    for (int i=0;i<(int)son[x].size();i++) {
        int kx=son[x][i];
        printf("%d %d\n",x,kx);
        Print(kx);
    }    
}
int main() {
    scanf("%d",&n);
    for (int i=1;i<=n;i++) {
        scanf("%lld",&d[i]);
        mp[d[i]]=i;
    }
    sort(d+1,d+n+1);
    for (int i=1;i<=n;i++) sz[i]=1;
    for (int i=n;i>1;i--) {
        int kx=mp[d[i]];
        if (sz[kx]*2>=n) {
            printf("-1\n");
            return 0;
        }
        fa[kx]=mp[d[i]-(n-sz[kx]*2)];
        if (fa[kx]==0) {
            printf("-1\n");
            return 0;
        }
        sz[fa[kx]]+=sz[kx];
        son[fa[kx]].push_back(kx);
    }
    Dfs(mp[d[1]]);
    if (sum!=d[1]) {
        printf("-1\n");
        return 0;
    }
    Print(mp[d[1]]);
    return 0;
}