Marmot found a row with n pillars. The i-th pillar has the height of hi meters. Starting from one pillar i1, Marmot wants to jump on the pillars i2, ..., ik. (1 ≤ i1 < i2 < ... < ik ≤ n). From a pillar i Marmot can jump on a pillar j only if i < j and |hi - hj| ≥ d, where |x| is the absolute value of the number x.

Now Marmot is asking you find out a jump sequence with maximal length and print it.

Input

The first line contains two integers n and d (1 ≤ n ≤ 105, 0 ≤ d ≤ 109).

The second line contains n numbers h1, h2, ..., hn (1 ≤ hi ≤ 1015).

Output

The first line should contain one integer k, the maximal length of a jump sequence.

The second line should contain k integers i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), representing the pillars' indices from the maximal length jump sequence.

If there is more than one maximal length jump sequence, print any.

Examples

Input

5 2
1 3 6 7 4


Output

4
1 2 3 5 


Input

10 3
2 1 3 6 9 11 7 3 20 18


Output

6
1 4 6 7 8 9 

Note

In the first example Marmot chooses the pillars 1, 2, 3, 5 with the heights 1, 3, 6, 4. Another jump sequence of length 4 is 1, 2, 4, 5.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class D {
	
	private static class ST {
		long l, r, mid;
		ST left, right;
		int value;
		public ST(long l, long r) {
			this.l = l;
			this.r = r;
			mid = (l+r)>>1;
		}
		
		public int query(long l, long r) {
			if (r < l || this.r < l || r < this.l) {
				return 0;
			}
			if (l <= this.l && this.r <= r) {
				return this.value;
			} else {
				int leftQ = left != null ? left.query(l, r) : 0;
				int rightQ = right != null ? right.query(l, r) : 0;
				return Math.max(leftQ, rightQ);
			}
		}
		
		public void update(long index, int v) {
			if (this.l == this.r) {
				this.value = v;
			} else {
				int leftV = left != null ? left.value : 0;
				int rightV = right != null ? right.value : 0;
				if (index <= mid) {
					if (left == null) {
						left = new ST(l, mid);
					}
					left.update(index, v);
					leftV = left.value;
				} else {
					if (right == null) {
						right = new ST(mid+1, r);
					}
					right.update(index, v);
					rightV = right.value;
				}
				this.value = Math.max(leftV, rightV);
			}
		}
	}

	
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), false);
		String[] parts = br.readLine().split(" ");
		int n = Integer.parseInt(parts[0]);
		int d = Integer.parseInt(parts[1]);
		long[] nums = new long[n];
		long[] sortedNums = new long[3*n];
		parts = br.readLine().split(" ");
		long max = 0;
		Map<Long, Integer> numToCompress = new HashMap<>();
		for (int i = 0; i < n; ++i) {
			sortedNums[3*i] = nums[i] = Long.parseLong(parts[i]) - 1;
			sortedNums[3*i + 1] = nums[i] + d;
			sortedNums[3*i + 2] = nums[i] - d;
			max = Math.max(nums[i], max);
		}
		Arrays.sort(sortedNums);
		for (int i = 0; i < sortedNums.length; ++i) {
			numToCompress.put(sortedNums[i], i);
		}
		max = numToCompress.get(max);
		ST root = new ST(0, max);
		int[] seq = new int[n];
		for (int i = 0; i < nums.length; ++i) {
			int m = Math.max(
					root.query(0, numToCompress.get(nums[i] - d)),
					root.query(numToCompress.get(nums[i] + d), max));
			root.update(numToCompress.get(nums[i]), m + 1);
			seq[i] = m+1;
		}
		int jumps = root.query(0, max);
		int currJump = jumps;
		int[] stack = new int[jumps];
		int stackInd = 0;
		long lastNum = -1;
		for (int i = seq.length - 1; i >= 0; --i) {
			if (seq[i] == currJump && (lastNum == -1 || Math.abs(lastNum - nums[i]) >= d)) {
				stack[stackInd++] = (i + 1);
				--currJump;
				lastNum = nums[i];
			}
		}
		out.println(jumps);
		for (int i = stack.length - 1; i >= 0; --i) {
			out.print(stack[i]);
			if (i != 0) out.print(' ');
		}
		out.println();
		out.close();
	}
}
