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;
inline char gc() {
  static char buf[100000], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
inline int read() {
  char c = getchar();
  int tot = 1;
  while ((c < '0' || c > '9') && c != '-') c = getchar();
  if (c == '-') {
    tot = -1;
    c = getchar();
  }
  int sum = 0;
  while (c >= '0' && c <= '9') {
    sum = sum * 10 + c - '0';
    c = getchar();
  }
  return sum * tot;
}
inline void wr(int x) {
  if (x < 0) {
    putchar('-');
    wr(-x);
    return;
  }
  if (x >= 10) wr(x / 10);
  putchar(x % 10 + '0');
}
inline void wrn(int x) {
  wr(x);
  putchar('\n');
}
inline void wri(int x) {
  wr(x);
  putchar(' ');
}
inline void wrn(int x, int y) {
  wri(x);
  wrn(y);
}
inline void wrn(int a, int b, int c) {
  wri(a);
  wrn(b, c);
}
int n, m, ans, k, a[500055], b[500055], z[500055];
signed main() {
  n = read();
  k = read();
  if (k == 1) {
    for (int i = (1); i <= (n); i++) wri(i);
    return 0;
  }
  for (int i = (1); i <= (n); i++) a[i] = read(), b[a[i]] = i;
  for (int i = (1); i <= (n); i++) {
    int t = a[i], p = i, tot = 0;
    for (int j = (t - 1); j >= (1); j--) {
      if (b[j] < i || p + k > n) break;
      if (b[j] - p >= k)
        a[b[j]] = a[i], b[a[i]] = b[j], a[i]--, b[a[i]] = i;
      else
        z[++tot] = b[j], p = max(p, b[j]);
    }
    for (int j = (1); j <= (tot); j++) a[z[j]] = a[i] - j, b[a[i] - j] = z[j];
  }
  for (int i = (1); i <= (n); i++) wri(a[i]);
  return 0;
}
