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.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) throws Exception {
		PrintWriter out = new PrintWriter(System.out);
		int arLen = nextInt();
		int d = nextInt();
		long[] ar = new long[arLen];
		long[] sorted = new long[arLen];
		HashMap<Long, Integer> map = new HashMap<>();
		for (int i = 0; i < ar.length; i++) {
			ar[i] = nextLong();
			sorted[i] = ar[i];
		}
		Arrays.sort(sorted);
		int[] mapped = new int[ar.length];
		int idx = 0;
		for (int i = 0; i < sorted.length; i++) {
			int j = i;
			while (j < sorted.length && sorted[j] == sorted[i]) {
				mapped[j] = idx;
				j++;
			}
			map.put(sorted[i], idx);
			i=j-1;
			++idx;
		}
		SegmentTree tree = new SegmentTree(idx);
		tree.init(-1);
		int[] next = new int[ar.length];
		Arrays.fill(next, -1);
		for (int i = ar.length - 1; i >= 0; i--) {
			long end = ar[i] + d;
			long st = ar[i] - d;
			int[] best = new int[] { -1, -1 };
			int idxEnd = Arrays.binarySearch(sorted, end);
			if (idxEnd < 0) {
				idxEnd += 1;
				idxEnd = -idxEnd;
			}
//			System.out.println(idxEnd);
			if (idxEnd < mapped.length) {
				idxEnd = mapped[idxEnd];
				int[] tmp = tree.query(idxEnd, idx - 1);
				if (tmp[1] > best[1]) {
					best = tmp;
				}
			}
			int idxSt = Arrays.binarySearch(sorted, st);
//			System.out.println(idxSt);
			if (idxSt < 0) {
				idxSt += 1;
				idxSt = -idxSt;
				idxSt--;
			}
			if (idxSt >= 0) {
				idxSt = mapped[idxSt];
				int[] tmp = tree.query(0, idxSt);
				if (tmp[1] > best[1]) {
					best = tmp;
				}
			}
//			System.out.println(i+" "+idxSt+" "+idxEnd+" "+best[0]+" "+best[1]+" "+map.get(ar[i]));
			if (best[0] == -1) {
				tree.update(map.get(ar[i]), 1, i);
			} else {
				next[i] = best[0];
				tree.update(map.get(ar[i]), best[1] + 1, i);
			}
		}
		int[] max = tree.query(0, idx - 1);
		out.println(max[1]);
		int cur = max[0];
		while (cur != -1) {
			out.print((cur + 1) + " ");
			cur = next[cur];
		}
		out.println();
		out.flush();
	}

	static class SegmentTree {
		int[][] T;
		int size = 1;
		static int inf;

		public SegmentTree(int n) {
			while (size < n)
				size <<= 1;
			T = new int[size << 1][2];
		}

		public void init(int v) {
			inf = v;
			for (int i = 0; i < T.length; i++) {
				T[i][0] = T[i][1] = v;
			}
		}

		// index is zero-based i.e. index=0 is the first element in the array
		public void update(int index, int v, int idx) {
			index += size;
			T[index][1] = v;
			T[index][0] = idx;
			while (index > 1) {
				index >>= 1;
				int[] tmp1 = T[index << 1];
				int[] tmp2 = T[(index << 1) + 1];
				if (tmp1[1] >= tmp2[1]) {
					T[index][0] = tmp1[0];
					T[index][1] = tmp1[1];
				} else {
					T[index][0] = tmp2[0];
					T[index][1] = tmp2[1];
				}
			}
		}

		// send query [i,j]
		public int[] query(int i, int j) {
			return query(1, 0, size - 1, i, j);
		}

		private int[] query(int node, int b, int e, int i, int j) {
			int[] p1, p2;
			if (i > e || j < b)
				return new int[] { inf, inf };
			if (b >= i && e <= j)
				return T[node];
			p1 = query(2 * node, b, (b + e) / 2, i, j);
			p2 = query(2 * node + 1, (b + e) / 2 + 1, e, i, j);
			if (p1[1] >= p2[1])
				return p1;
			return p2;
		}
	}

	static BufferedReader br = new BufferedReader(new InputStreamReader(
			System.in));
	static StringTokenizer tokenizer = new StringTokenizer("");

	static int nextInt() throws Exception {
		return Integer.parseInt(next());
	}
	static long nextLong() throws Exception {
		return Long.parseLong(next());
	}

	static double nextDouble() throws Exception {
		return Double.parseDouble(next());
	}

	static String next() throws Exception {
		while (true) {
			if (tokenizer.hasMoreTokens()) {
				return tokenizer.nextToken();
			}
			String s = br.readLine();
			if (s == null) {
				return null;
			}
			tokenizer = new StringTokenizer(s);
		}
	}
}
