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;
const int N = 1000000 + 7;
int n, k, Ord[N], Min[N], Ans[N], In[N];
vector<int> E[N];
void Update(int u, int l, int r, int Pos, int w) {
  if (l == r) {
    Min[u] = min(Min[u], w);
    return;
  }
  int Mid = (l + r) >> 1;
  if (Mid >= Pos)
    Update((u << 1), l, Mid, Pos, w);
  else
    Update((u << 1 | 1), Mid + 1, r, Pos, w);
  Min[u] = min(Min[(u << 1)], Min[(u << 1 | 1)]);
}
int Query(int u, int l, int r, int L, int R) {
  if (L > R) return Min[0];
  if (L <= l && R >= r) return Min[u];
  int Mid = (l + r) >> 1, Ret = Min[0];
  if (Mid >= L) Ret = Query((u << 1), l, Mid, L, R);
  if (Mid < R) Ret = min(Ret, Query((u << 1 | 1), Mid + 1, r, L, R));
  return Ret;
}
priority_queue<int> Q;
inline void TopSort() {
  int Sz = 0;
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
    if (!In[i]) Q.push(-i);
  while (!Q.empty()) {
    int u = Q.top();
    Q.pop();
    Ans[-u] = (++(Sz));
    for (auto v : E[-u])
      if (!(--(In[v]))) Q.push(-v);
  }
}
int main() {
  int x;
  scanf("%d%d", &n, &k);
  memset(Min, 127, sizeof(Min));
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
    scanf("%d", &x), Ord[x] = i;
  for (int i = (n), iLimit = (1); i >= iLimit; (--(i))) {
    int t = Query(1, 1, n, max(1, Ord[i] - k + 1), Ord[i] - 1);
    if (t != Min[0]) E[Ord[i]].push_back(Ord[t]), (++(In[Ord[t]]));
    t = Query(1, 1, n, Ord[i] + 1, min(n, Ord[i] + k - 1));
    if (t != Min[0]) E[Ord[i]].push_back(Ord[t]), (++(In[Ord[t]]));
    Update(1, 1, n, Ord[i], i);
  }
  TopSort();
  for (int i = (1), iLimit = (n); i <= iLimit; (++(i))) printf("%d\n", Ans[i]);
  return 0;
}
