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.*;
import java.util.*;

public class Main {
	static Scanner sc = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static StringBuilder sb = new StringBuilder();
	static int parent[];

	public static void main(String[] args) throws Exception {
		int n = sc.nextInt(), d = sc.nextInt(), ans = 0, fst = 0;
		parent = new int[n + 5];
		long h[] = new long[n + 5];
		Comp comp = new Comp();

		for (int i = 1; i <= n; i++) {
			h[i] = sc.nextLong();
			comp.add(h[i]);
			if (h[i] - d >= 0)
				comp.add(h[i] - d);
			comp.add(h[i] + d);
		}
		comp.update();
		SegmentTree seg = new SegmentTree(comp.getSize());
		for (int i = 1; i <= n; i++) {
			int q[] = seg.query(comp.get(h[i] + d), comp.getSize());
			if (h[i] - d >= 0) {
				int q2[] = seg.query(1, comp.get(h[i] - d));
				if (q2[1] > q[1])
					q = q2;
			}

			seg.updatePoint(comp.get(h[i]), new int[] { i, q[1] + 1 });
			parent[i] = q[0];
			if (q[1] + 1 > ans) {
				ans = q[1] + 1;
				fst = i;
			}
		}

		out.println(ans);
		print(fst);
		out.println(sb);
		out.close();
	}

	static void print(int p) {
		if (p == -1) {
			return;
		}
		print(parent[p]);
		sb.append(p + " ");
	}
}

class Comp {
	TreeSet<Long> st = new TreeSet<>();
	HashMap<Long, Integer> mp = new HashMap<>();

	void add(long h) {
		st.add(h);
	}

	void update() {
		int val = 1;
		for (long h : st) {
			mp.put(h, val++);
		}
	}

	int get(long h) {
		return mp.get(h);
	}

	int getSize() {
		return mp.size();
	}

}

class SegmentTree {
	int N;
	int stree[][];

	SegmentTree(int n) {
		N = n;
		stree = new int[2][N << 2];
		Arrays.fill(stree[0], -1);
		Arrays.fill(stree[1], 0);
	}

	void updatePoint(int node, int l, int r, int idx, int[] val) {
		if (l == r) {
			stree[0][node] = val[0];
			stree[1][node] = val[1];
			return;
		}
		int mid = (l + r) >> 1;
		if (idx <= mid)
			updatePoint(node << 1, l, mid, idx, val);
		else
			updatePoint(node << 1 | 1, mid + 1, r, idx, val);

		if (stree[1][node << 1] > stree[1][node << 1 | 1]) {
			stree[1][node] = stree[1][node << 1];
			stree[0][node] = stree[0][node << 1];
		} else {
			stree[1][node] = stree[1][node << 1 | 1];
			stree[0][node] = stree[0][node << 1 | 1];
		}
	}

	void updatePoint(int idx, int[] val) { // Input index 1-based
		updatePoint(1, 1, N, idx, val);
	}

	int[] query(int i, int j) {
		return query(1, 1, N, i, j);
	}

	int[] query(int node, int b, int e, int i, int j) {
		if (i > e || j < b)
			return new int[] { -1, 0 };
		if (b >= i && e <= j)
			return new int[] { stree[0][node], stree[1][node] };
		int mid = b + e >> 1;
		int q1[] = query(node << 1, b, mid, i, j);
		int q2[] = query(node << 1 | 1, mid + 1, e, i, j);
		if (q1[1] > q2[1]) return q1;
		return q2;
	}
}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream system) {
		br = new BufferedReader(new InputStreamReader(system));
	}

	public Scanner(String file) throws Exception {
		br = new BufferedReader(new FileReader(file));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public Long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}
