Let A = {a1, a2, ..., an} be any permutation of the first n natural numbers {1, 2, ..., n}. You are given a positive integer k and another sequence B = {b1, b2, ..., bn}, where bi is the number of elements aj in A to the left of the element at = i such that aj ≥ (i + k).

For example, if n = 5, a possible A is {5, 1, 4, 2, 3}. For k = 2, B is given by {1, 2, 1, 0, 0}. But if k = 3, then B = {1, 1, 0, 0, 0}.

For two sequences X = {x1, x2, ..., xn} and Y = {y1, y2, ..., yn}, let i-th elements be the first elements such that xi ≠ yi. If xi < yi, then X is lexicographically smaller than Y, while if xi > yi, then X is lexicographically greater than Y.

Given n, k and B, you need to determine the lexicographically smallest A.

Input

The first line contains two space separated integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ n). On the second line are n integers specifying the values of B = {b1, b2, ..., bn}.

Output

Print on a single line n integers of A = {a1, a2, ..., an} such that A is lexicographically minimal. It is guaranteed that the solution exists.

Examples

Input

5 2
1 2 1 0 0


Output

4 1 5 2 3 

Input

4 2
1 0 0 0


Output

2 3 1 4 

import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class Manthan2011_B implements Runnable {

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	@Override
	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			init();
			solve();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Exception e) {
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	public static void main(String[] args) {
		new Thread(new Manthan2011_B()).start();
	}

	int n,k;
	int[] b,a;
	
	void solve() throws IOException {
		n = readInt();
		k = readInt();
		b = new int[n+1];
		for (int i = 1; i <= n; i++) {
			b[i] = readInt();
		}
		a = new int[n+2];
		for (int i = 1; i <= n; i++) {
			a[i] = i;
		}
		
		for (int i = n - k; i >= 1; i--) {
			int need = b[i];
			int what = i + k;
			int pos = pos(i);
			int have = get(pos, what);
			if (need == have) continue;
			if (need < have) {
				int count = have - need;
				for (int j = pos - 1; j >= 1; j--) {
					if (a[j] >= what) {
						count--;
					}
					swap(j, j+1);
					if (count == 0) break;
				}
			} else {
				int count = have - need;
				for (int j = pos + 1; j <= n; j++) {
					if (a[j] >= what) {
						count++;
					}
					swap(j-1, j);
					if (count == 0) break;
				}
			}
		}
		
		for (int i = 1; i <= n; i++) {
			out.print(a[i] + " ");
		}
	}
	
	void swap(int i, int j) {
		int t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	
	int pos(int value) {
		for (int i = 1; i <= n; i++) {
			if (a[i] == value) return i; 
		}
		throw new RuntimeException();
	}
	
	int get(int right, int value) {
		int ans = 0;
		for (int i = 1; i < right; i++) {
			if (a[i] >= value) ans++;
		}		
		return ans;
	}
	
}
