#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
void redirectIO() {
  ios::sync_with_stdio(false);
  cin.tie(0);
}
long long mVal[1100000];
long long upd[1100000];
long long s[210000];
void refr(int a) { mVal[a] = mVal[a * 2] + mVal[a * 2 + 1] + upd[a]; }
void push(int a) {
  mVal[a * 2] += upd[a];
  upd[a * 2] += upd[a];
  mVal[a * 2 + 1] += upd[a];
  upd[a * 2 + 1] += upd[a];
  upd[a] = 0;
}
void build(int a, int beg, int end) {
  if (beg == end) {
    mVal[a] = beg - 1;
    return;
  }
  build(a * 2, beg, (beg + end) / 2);
  build(a * 2 + 1, (beg + end) / 2 + 1, end);
  refr(a);
}
int targ_end;
int targ_beg;
long long targ_val;
void update(int a, int beg, int end) {
  if (beg > targ_end || end < targ_beg) return;
  if (beg >= targ_beg && end <= targ_end) {
    upd[a] += targ_val;
    mVal[a] += targ_val;
    return;
  }
  push(a);
  update(a * 2, beg, (beg + end) / 2);
  update(a * 2 + 1, (beg + end) / 2 + 1, end);
  refr(a);
}
int findIndex(int a, int beg, int end) {
  if (beg == end) {
    return beg;
  }
  push(a);
  if (mVal[a * 2] < targ_val) {
    targ_val -= mVal[a * 2];
    return findIndex(a * 2 + 1, (beg + end) / 2 + 1, end);
  }
  return findIndex(a * 2, beg, (beg + end) / 2);
}
int main() {
  redirectIO();
  int n;
  cin >> n;
  for (int i = 1; i <= (n); i++) cin >> s[i];
  build(1, 1, n);
  set<int> ss;
  for (int i = 1; i <= (n); i++) ss.insert(i);
  vector<int> answer;
  for (int i = n; i > 0; --i) {
    targ_val = s[i];
    int b = findIndex(1, 1, n);
    int a = *ss.lower_bound(b);
    ss.erase(a);
    answer.push_back(a);
    targ_beg = a + 1;
    targ_end = a + 1;
    targ_val = -a;
    update(1, 1, n);
  }
  reverse(answer.begin(), answer.end());
  for (int x : answer) cout << x << " ";
  return 0;
}

### Prompt

Please formulate a CPP solution to the following problem:

An array of integers p_{1},p_{2}, …,p_{n} is called a permutation if it contains each number from 1 to n exactly once. For example, the following arrays are permutations: [3,1,2], [1], [1,2,3,4,5] and [4,3,1,2]. The following arrays are not permutations: [2], [1,1], [2,3,4].

There is a hidden permutation of length n.

For each index i, you are given s_{i}, which equals to the sum of all p_{j} such that j < i and p_{j} < p_{i}. In other words, s_i is the sum of elements before the i-th element that are smaller than the i-th element.

Your task is to restore the permutation.

Input

The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the size of the permutation.

The second line contains n integers s_{1}, s_{2}, …, s_{n} (0 ≤ s_{i} ≤ (n(n-1))/(2)).

It is guaranteed that the array s corresponds to a valid permutation of length n.

Output

Print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation. We can show that the answer is always unique.

Examples

Input


3
0 0 0


Output


3 2 1


Input


2
0 1


Output


1 2


Input


5
0 1 1 1 10


Output


1 4 3 2 5

Note

In the first example for each i there is no index j satisfying both conditions, hence s_i are always 0.

In the second example for i = 2 it happens that j = 1 satisfies the conditions, so s_2 = p_1.

In the third example for i = 2, 3, 4 only j = 1 satisfies the conditions, so s_2 = s_3 = s_4 = 1. For i = 5 all j = 1, 2, 3, 4 are possible, so s_5 = p_1 + p_2 + p_3 + p_4 = 10.

### Response

```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
void redirectIO() {
  ios::sync_with_stdio(false);
  cin.tie(0);
}
long long mVal[1100000];
long long upd[1100000];
long long s[210000];
void refr(int a) { mVal[a] = mVal[a * 2] + mVal[a * 2 + 1] + upd[a]; }
void push(int a) {
  mVal[a * 2] += upd[a];
  upd[a * 2] += upd[a];
  mVal[a * 2 + 1] += upd[a];
  upd[a * 2 + 1] += upd[a];
  upd[a] = 0;
}
void build(int a, int beg, int end) {
  if (beg == end) {
    mVal[a] = beg - 1;
    return;
  }
  build(a * 2, beg, (beg + end) / 2);
  build(a * 2 + 1, (beg + end) / 2 + 1, end);
  refr(a);
}
int targ_end;
int targ_beg;
long long targ_val;
void update(int a, int beg, int end) {
  if (beg > targ_end || end < targ_beg) return;
  if (beg >= targ_beg && end <= targ_end) {
    upd[a] += targ_val;
    mVal[a] += targ_val;
    return;
  }
  push(a);
  update(a * 2, beg, (beg + end) / 2);
  update(a * 2 + 1, (beg + end) / 2 + 1, end);
  refr(a);
}
int findIndex(int a, int beg, int end) {
  if (beg == end) {
    return beg;
  }
  push(a);
  if (mVal[a * 2] < targ_val) {
    targ_val -= mVal[a * 2];
    return findIndex(a * 2 + 1, (beg + end) / 2 + 1, end);
  }
  return findIndex(a * 2, beg, (beg + end) / 2);
}
int main() {
  redirectIO();
  int n;
  cin >> n;
  for (int i = 1; i <= (n); i++) cin >> s[i];
  build(1, 1, n);
  set<int> ss;
  for (int i = 1; i <= (n); i++) ss.insert(i);
  vector<int> answer;
  for (int i = n; i > 0; --i) {
    targ_val = s[i];
    int b = findIndex(1, 1, n);
    int a = *ss.lower_bound(b);
    ss.erase(a);
    answer.push_back(a);
    targ_beg = a + 1;
    targ_end = a + 1;
    targ_val = -a;
    update(1, 1, n);
  }
  reverse(answer.begin(), answer.end());
  for (int x : answer) cout << x << " ";
  return 0;
}

```