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.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*; 
import java.util.*;
import java.util.regex.*;
/*
	  br = new BufferedReader(new FileReader("input.txt"));
	  pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
	  br = new BufferedReader(new InputStreamReader(System.in));
	  pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */


public class Main {
	private static BufferedReader br;
	private static StringTokenizer st;
	private static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		//int qq = 1;
		int qq = Integer.MAX_VALUE;
		//int qq = readInt();
		outer: for(int casenum = 1; casenum <= qq; casenum++) {
			int n = readInt();
			int d = readInt();
			TreeSet<Long> set = new TreeSet<Long>();
			long[] list = new long[n];
			Map<Long, TreeSet<Integer>> locs = new HashMap<Long, TreeSet<Integer>>();
			for(int i = 0; i < n; i++) {
				set.add(list[i] = readLong());
				if(!locs.containsKey(list[i])) {
					locs.put(list[i], new TreeSet<Integer>());
				}
				locs.get(list[i]).add(i);
			}
			long[] reverseD = new long[set.size()];
			Map<Long, Integer> discrete = new HashMap<Long, Integer>();
			for(long out: set) {
				reverseD[discrete.size()] = out;
				discrete.put(out, discrete.size());
			}
			RangeTree tree = new RangeTree(discrete.size());
			int[] parent = new int[n];
			int[] dp = new int[n];
			Arrays.fill(dp, 1);
			Arrays.fill(parent, -1);
			
			long[] lows = new long[n+1];
			long[] highs = new long[n+1];
			Arrays.fill(lows, Long.MAX_VALUE);
			
			for(int i = 0; i < n; i++) {
				if(set.first() <= list[i] - d) {
					long value = set.floor(list[i] - d);
					int lowIndex = discrete.get(value);
					int update = 1 + tree.query(0, lowIndex);
					if(update > dp[i]) {
						dp[i] = update;
						parent[i] = locs.get(lows[update-1]).lower(i);
					}
				}
				if(set.last() >= list[i] + d) {
					long value = set.ceiling(list[i] + d);
					int highIndex = discrete.get(value);
					int update = 1 + tree.query(highIndex, discrete.size() - 1);
					if(update > dp[i]) {
						dp[i] = update;
						parent[i] = locs.get(highs[update-1]).lower(i);
					}
				}
				tree.update(discrete.get(list[i]), dp[i]);
				lows[dp[i]] = Math.min(lows[dp[i]], list[i]);
				highs[dp[i]] = Math.max(highs[dp[i]], list[i]);
			}
			int bestIndex = 0;
			for(int i = 1; i < n; i++) {
				if(dp[i] > dp[bestIndex]) {
					bestIndex = i;
				}
			}
			pw.println(dp[bestIndex]);
			LinkedList<Integer> ret = new LinkedList<Integer>();
			ret.add(bestIndex);
			while(dp[bestIndex] > 1) {
				bestIndex = parent[bestIndex];
				ret.addFirst(bestIndex);
			}
			for(int out: ret) {
				pw.print(++out + " ");
			}
			pw.println();
		}
		exitImmediately();
	}

	static class RangeTree {
		public int[] leaf;
		public int size;
		public RangeTree(int in) {
			size = in;
			leaf = new int[4*in];
		}
		public void update(int index, int val) {
			update(1, 0, size-1, index, val);
		}
		public void update(int index, int l, int r, int in, int val) {
			if(in < l || in > r) return;
			if(l == r) {
				leaf[index] = Math.max(leaf[index], val);
			}
			else {
				int m = (l+r)/2;
				update(2*index, l, m, in, val);
				update(2*index+1, m+1, r, in, val);
				leaf[index] = Math.max(leaf[2*index], leaf[2*index+1]);
			}
		}
		public int query(int l, int r) {
			return query(1, 0, size-1, l, r);
		}
		public int query(int treeIndex, int tL, int tR, int l, int r) {
			if(l > tR || r < tL) return 0;
			if(tL >= l && tR <= r) {
				return leaf[treeIndex];
			}
			int tM = (tL+tR)/2;
			int ret = 0;
			ret = Math.max(ret, query(2*treeIndex, tL, tM, l, r));
			ret = Math.max(ret, query(2*treeIndex+1, tM+1, tR, l, r));
			return ret;
		}
	}

	private static void exitImmediately() {
		pw.close();
		System.exit(0);
	}

	private static long readLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private static double readDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	private static int readInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	private static String nextLine() throws IOException  {
		if(!br.ready()) {
			exitImmediately();
		}
		st = null;
		return br.readLine();
	}

	private static String nextToken() throws IOException  {
		while(st == null || !st.hasMoreTokens())  {
			if(!br.ready()) {
				exitImmediately();
			}
			st = new StringTokenizer(br.readLine().trim());
		}
		return st.nextToken();
	}
}

