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 = 1 << 19;
int n, k, a[maxn], pos[maxn];
struct sgt {
  int val[maxn << 1];
  void modify(int i, int v) {
    i += maxn;
    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;
    l = max(l, 1), r = min(r, n + 1);
    l += maxn, r += maxn;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1) res = max(res, val[l++]);
      if (r & 1) res = max(res, val[--r]);
    }
    return res;
  }
} tree;
void bf(int l, int r) {
  bool c = true;
  while (c) {
    c = false;
    for (int j = l + 1; j <= r; ++j)
      if (abs(pos[j] - pos[j - 1]) >= k && pos[j] < pos[j - 1])
        c = true, swap(pos[j], pos[j - 1]);
    for (int j = r; j >= l + 1; --j)
      if (abs(pos[j] - pos[j - 1]) >= k && pos[j] < pos[j - 1])
        c = true, swap(pos[j], pos[j - 1]);
  }
}
set<int> st;
void solve(int l, int r) {
  static int cp[maxn], pri[maxn];
  static vector<int> q[maxn];
  if (r <= l) return;
  if (false && r - l + 1 <= 100)
    bf(l, r);
  else {
    int m = l + r >> 1;
    solve(l, m);
    solve(m + 1, r);
    for (int i = l; i <= m; ++i) tree.modify(pos[i], i), st.insert(pos[i]);
    int lst = l - 1;
    for (int i = m + 1; i <= r; ++i) {
      int p = tree.query(1, pos[i]);
      auto invalid = [&]() {
        auto it = st.lower_bound(pos[i]);
        return it != end(st) && *it - pos[i] < k;
      };
      while (lst < p || (lst < m && invalid())) {
        if (lst != l - 1) st.erase(pos[lst]);
        ++lst;
      }
      q[lst].emplace_back(pos[i]);
    }
    for (int i = l; i <= r; ++i) tree.modify(pos[i], 0);
    st.clear();
    int h = l;
    for (int i = l - 1; i <= m; ++i) {
      if (i != l - 1) cp[h++] = pos[i];
      for (int u : q[i]) cp[h++] = u;
      q[i].clear();
    }
    copy(cp + l, cp + r + 1, pos + l);
  }
}
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;
  solve(1, n);
  for (int i = 1; i <= n; ++i) a[pos[i]] = i;
  for (int i = 1; i <= n; ++i) cout << a[i] << '\n';
}
