/*
Look at inverse permutation: can make adjacent swaps i, i+1 iff |Q[i]-Q[i+1]| >= K.
Then if |Q[i]-Q[j]| < K, we cannot change the relative order.
All other permutations are possible: we can always find an adjacent swap and decrease # inversions by 1.
(if we cannot swap i, i+1, this means |Q[i]-Q[i+1]| < K, contradiction.)
So back to original permutation P, this means we want a lex min labeling such that:
- if |i-j| < K, then P[i] < P[j] or P[i] > P[j] needs to hold true.
Draw i->j if P[i] < P[j] must be true. We want a lex least topo sort.
Algo: find outdeg=0 nodes, and assign rightmost to n.
outdeg[i] = 0 means i is a local maximum in P. (P[i] >= P[i-K+1..i+K-1]).
Maintain # in window that is > P[i] for each i.
*/
#include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
	return os << "(" << x.first << "," << x.second << ")";
}
typedef long long ll;
typedef long double ld;
struct SegTree {
	struct Node {
		pair<int, int> mn; // Set default value here
		int prop = 0;
		// Used for updates and propagation.
		void apply(int s, int e, int v) {
			mn.first += v;
			prop += v;
		}
	};
	inline Node combine(const Node& a, const Node& b) {
		Node res;
		res.mn = min(a.mn, b.mn);
		return res;
	}
	inline void push(int sn, int s, int e) {
		if (tree[sn].prop) {
			int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
			tree[lsn].apply(s, m, tree[sn].prop);
			tree[rsn].apply(m + 1, e, tree[sn].prop);
			tree[sn].prop = 0;
		}
	}
	int start, end;
	vector<Node> tree;
	void build(int sn, int s, int e) {
		if (s == e) {
			// initialize here, possibly.
			tree[sn].mn = {0, -s};
			return;
		}
		int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
		build(lsn, s, m);
		build(rsn, m + 1, e);
		tree[sn] = combine(tree[lsn], tree[rsn]);
	}
	template <typename T>
	void build(int sn, int s, int e, vector<T>& v) {
		if (s == e) {
//			tree[sn].x = v[s];
			return;
		}
		int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
		build(lsn, s, m, v);
		build(rsn, m + 1, e, v);
		tree[sn] = combine(tree[lsn], tree[rsn]);
	}
	template <typename... T>
	void update(int sn, int s, int e, int qs, int qe, const T&... v) {
		if (qs <= s && e <= qe) {
			tree[sn].apply(s, e, v...);
			return;
		}
		int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
		push(sn, s, e);
		if (qs <= m) update(lsn, s, m, qs, qe, v...);
		if (qe > m) update(rsn, m + 1, e, qs, qe, v...);
		tree[sn] = combine(tree[lsn], tree[rsn]);
	}
	Node query(int sn, int s, int e, int qs, int qe) {
		if (qs <= s && e <= qe) return tree[sn];
		int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
		push(sn, s, e);
		if (qe <= m) return query(lsn, s, m, qs, qe);
		if (qs > m) return query(rsn, m + 1, e, qs, qe);
		return combine(query(lsn, s, m, qs, qe), query(rsn, m + 1, e, qs, qe));
	}
	void query(int sn, int s, int e, int qs, int qe, const function<void(Node&, int, int)>& f) {
		if (qs <= s && e <= qe) return f(tree[sn], s, e);
		int m = (s + e) >> 1, lsn = sn * 2, rsn = sn * 2 + 1;
		push(sn, s, e);
		if (qs <= m) query(lsn, s, m, qs, qe, f);
		if (qe > m) query(rsn, m + 1, e, qs, qe, f);
	}
	SegTree(int n) : SegTree(0, n - 1) {}
	SegTree(int _start, int _end) : start(_start), end(_end) {
		int n = end - start + 1;
		int maxs = n == 1 ? 2 : 1 << (33 - __builtin_clz(n - 1));
		tree.resize(maxs);
		build(1, start, end);
	}
	template <typename T>
	SegTree(vector<T>& v) {
		int n = v.size();
		int maxs = n == 1 ? 2 : 1 << (33 - __builtin_clz(n - 1));
		tree.resize(maxs);
		start = 0;
		end = n - 1;
		build(1, start, end, v);
	}
	Node query(int qs, int qe) {
		return query(1, start, end, qs, qe);
	}
	Node query(int p) {
		return query(1, start, end, p, p);
	}
	void query(int qs, int qe, const function<void(Node&, int, int)>& f) {
		if (qs > qe) return;
		query(1, start, end, qs, qe, f);
	}
	template <typename... T>
	void update(int qs, int qe, const T&... v) {
		update(1, start, end, qs, qe, v...);
	}
};
const int INF = 1e9;
int main() {
	int n, k;
	scanf("%d%d", &n, &k);
	vector<int> P(n), ind(n + 1), ans(n);
	for (int i = 0; i < n; ++i) {
		scanf("%d", &P[i]);
		ind[P[i]] = i;
	}
	SegTree st(n);
	for (int i = 1; i <= n; ++i) {
		int p = ind[i];
		st.update(max(0, p - k + 1), min(n - 1, p + k - 1), 1);
		st.update(p, p, -st.query(p, p).mn.first);
	}
	for (int i = n; i >= 1; --i) {
		auto x = st.query(0, n - 1).mn;
		assert(x.first == 0);
		int p = -x.second;
		ans[p] = i;
		st.update(max(0, p - k + 1), min(n - 1, p + k - 1), -1);
		st.update(p, p, INF);
	}
	for (int x : ans) printf("%d\n", x);
}


Measured memory_bytes: 21760