You are given a permutation P_1 ... P_N of the set {1, 2, ..., N}.

You can apply the following operation to this permutation, any number of times (possibly zero):

* Choose two indices i,j (1 ≦ i < j ≦ N), such that j - i ≧ K and |P_i - P_j| = 1. Then, swap the values of P_i and P_j.



Among all permutations that can be obtained by applying this operation to the given permutation, find the lexicographically smallest one.

Constraints

* 2≦N≦500,000
* 1≦K≦N-1
* P is a permutation of the set {1, 2, ..., N}.

Input

The input is given from Standard Input in the following format:


N K
P_1 P_2 ... P_N


Output

Print the lexicographically smallest permutation that can be obtained.

Examples

Input

4 2
4 2 3 1


Output

2
1
4
3


Input

5 1
5 4 3 2 1


Output

1
2
3
4
5


Input

8 3
4 5 7 8 3 1 2 6


Output

1
2
6
7
5
3
4
8
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 500010, inf = maxn + 1;
int n, a[maxn], pos[maxn], k;
struct SGT {
  int val[maxn << 1];
  void modify(int i, int v) {
    i += n + 1;
    val[i] = v;
    for (; i >>= 1;) val[i] = max(val[i << 1], val[i << 1 | 1]);
  }
  int query(int l, int r) {
    int res = 0;
    r = min(r, n + 1);
    l = max(l, 1);
    for (l += n + 1, r += n + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1) res = max(res, val[l++]);
      if (r & 1) res = max(res, val[--r]);
    }
    return res;
  }
} sgt;
bool ok[maxn];
int h = 1;
pair<int, int> lst[maxn];
int get_nxt(int v) {
  int a, b;
  tie(a, b) = lst[v];
  return !ok[a] && !ok[b] ? min(a, b) : ok[a] ? b : a;
}
void init() {
  ok[0] = true;
  for (int i = 1; i <= n; ++i) {
    lst[pos[i]] = {pos[sgt.query(pos[i], pos[i] + k)],
                   pos[sgt.query(pos[i] - k, pos[i])]};
    sgt.modify(pos[i], i);
  }
}
int res[maxn];
signed main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  cin >> n >> k;
  for (int i = 1; i <= n; ++i) cin >> a[i], pos[a[i]] = i;
  init();
  for (int i = 1; i <= n; ++i)
    if (!ok[i]) {
      vector<int> mv{i};
      int p = i, nxt;
      ;
      while (!ok[(nxt = get_nxt(p))]) {
        ;
        mv.emplace_back(p = nxt);
      }
      reverse(mv.begin(), mv.end());
      for (int x : mv) {
        ok[x] = true;
        res[x] = h++;
      }
    }
  for (int i = 1; i <= n; ++i) cout << res[i] << '\n';
}
