#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
  long long w, change;
  int in;
};
vector<long long> a;
vector<node> t;
const long long INF = 1e18;
node combine(node a, node b, long long change) {
  a.w += a.change;
  b.w += b.change;
  node res;
  if (a.w != b.w)
    res = (a.w < b.w) ? a : b;
  else
    res = (a.in > b.in) ? a : b;
  res.change = change;
  return res;
}
void build(int v, int tl, int tr) {
  if (tl == tr) {
    t[v] = {a[tl], 0, tl};
    return;
  }
  int tm = (tl + tr) / 2;
  build(2 * v, tl, tm);
  build(2 * v + 1, tm + 1, tr);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void delete_el(int v, int tl, int tr, int pos) {
  if (tl == tr) {
    t[v] = {INF, 0, 0};
    return;
  }
  int tm = (tl + tr) / 2;
  if (pos <= tm)
    delete_el(2 * v, tl, tm, pos);
  else
    delete_el(2 * v + 1, tm + 1, tr, pos);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void update(int v, int tl, int tr, int l, int r, long long val) {
  if (l > r) return;
  if (l == tl && r == tr) {
    t[v].change -= val;
    return;
  }
  int tm = (tl + tr) / 2;
  update(2 * v, tl, tm, l, min(r, tm), val);
  update(2 * v + 1, tm + 1, tr, max(l, tm + 1), r, val);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
int main() {
  int n;
  cin >> n;
  a.resize(n);
  t.resize(4 * n);
  for (int i = 0; i < n; i++) cin >> a[i];
  build(1, 0, n - 1);
  vector<long long> ans(n);
  for (int i = 0; i < n; i++) {
    int in = t[1].in;
    ans[in] = i + 1;
    delete_el(1, 0, n - 1, in);
    update(1, 0, n - 1, in + 1, n - 1, i + 1);
  }
  for (int i = 0; i < n; i++) cout << ans[i] << " ";
  cout << "\n";
  return 0;
}

### Prompt

In Cpp, your task is to solve 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>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
  long long w, change;
  int in;
};
vector<long long> a;
vector<node> t;
const long long INF = 1e18;
node combine(node a, node b, long long change) {
  a.w += a.change;
  b.w += b.change;
  node res;
  if (a.w != b.w)
    res = (a.w < b.w) ? a : b;
  else
    res = (a.in > b.in) ? a : b;
  res.change = change;
  return res;
}
void build(int v, int tl, int tr) {
  if (tl == tr) {
    t[v] = {a[tl], 0, tl};
    return;
  }
  int tm = (tl + tr) / 2;
  build(2 * v, tl, tm);
  build(2 * v + 1, tm + 1, tr);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void delete_el(int v, int tl, int tr, int pos) {
  if (tl == tr) {
    t[v] = {INF, 0, 0};
    return;
  }
  int tm = (tl + tr) / 2;
  if (pos <= tm)
    delete_el(2 * v, tl, tm, pos);
  else
    delete_el(2 * v + 1, tm + 1, tr, pos);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
void update(int v, int tl, int tr, int l, int r, long long val) {
  if (l > r) return;
  if (l == tl && r == tr) {
    t[v].change -= val;
    return;
  }
  int tm = (tl + tr) / 2;
  update(2 * v, tl, tm, l, min(r, tm), val);
  update(2 * v + 1, tm + 1, tr, max(l, tm + 1), r, val);
  t[v] = combine(t[2 * v], t[2 * v + 1], t[v].change);
}
int main() {
  int n;
  cin >> n;
  a.resize(n);
  t.resize(4 * n);
  for (int i = 0; i < n; i++) cin >> a[i];
  build(1, 0, n - 1);
  vector<long long> ans(n);
  for (int i = 0; i < n; i++) {
    int in = t[1].in;
    ans[in] = i + 1;
    delete_el(1, 0, n - 1, in);
    update(1, 0, n - 1, in + 1, n - 1, i + 1);
  }
  for (int i = 0; i < n; i++) cout << ans[i] << " ";
  cout << "\n";
  return 0;
}

```