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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Arrays;

public class Pillars {

	static int n;
	static long d;
	static long a[] , b[];
	static int dp[] , prev[];
	static SegmentTree tree;
	static final int oo = Integer.MAX_VALUE/2;
	
	public static void main(String args[] ) throws Exception {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter w = new PrintWriter(System.out);
	        
	    StringTokenizer st1 = new StringTokenizer(br.readLine());
	    n = ip(st1.nextToken());
		d = ip(st1.nextToken());
	          
		a = new long[n];
		b = new long[n];
	    StringTokenizer st2 = new StringTokenizer(br.readLine());
	    for(int i=0;i<n;i++)
	    	a[i] = b[i] = Long.parseLong(st2.nextToken());
	    	
	    Arrays.sort(b);
	    
	    tree = new SegmentTree(n);
	    
	    dp = new int[n];
	    Arrays.fill(dp,1);
	    prev = new int[n];
	    Arrays.fill(prev,-1);
	  
	    for(int i=0;i<n;i++){
	    	int lo = -1, hi = n;
			while(hi - lo > 1) {
				int m = lo + (hi - lo) / 2;
				if (b[m] <= a[i] - d) {
					lo = m;
				}else {
					hi = m;
				}
			}
			if (lo != -1) {
				Node node = tree.query(0, lo);
				if (node.value != -oo) {
					if (dp[i] < node.value + 1) {
						dp[i] = node.value + 1;
						prev[i] = node.idx;
					}
				}
			}

			lo = -1;
			hi = n;
			while(hi - lo > 1) {
				int m = lo + (hi - lo) / 2;
				if (b[m] >= a[i] + d) {
					hi = m;
				}else {
					lo = m;
				}
			}

			if (hi != n) {
				Node node = tree.query(hi, n - 1);
				if (node.value != -oo) {
					if (dp[i] < node.value + 1) {
						dp[i] = node.value + 1;
						prev[i] = node.idx;
					}
				}
			}

			lo = -1;
			hi = n;
			while(hi - lo > 1) {
				int m = lo + (hi - lo) / 2;
				if (b[m] <= a[i]) {
					lo = m;
				}else {
					hi = m;
				}
			}

			tree.update(lo, dp[i], i);

	    }
	    
	    int last = -1;
		for(int i = 0; i < n; ++i) {
			if (last == -1 || dp[i] > dp[last]) {
				last = i;
			}
		}

		w.println(dp[last]);
		List<Integer> ans = new ArrayList<Integer>();
		while(last != -1) {
			ans.add(last + 1);
			last = prev[last];
		}
		Collections.reverse(ans);
		for(int i : ans) {
			w.print(i + " ");
		}
		w.println();
		// out.println(Arrays.toString(dp));
		// out.println(Arrays.toString(prev));

		w.close();

	}

	public static int ip(String s){
		return Integer.parseInt(s);
	}	

}

class SegmentTree {
	Node []tree;
	int n,oo;

	public SegmentTree(int n) {
		this.n = n;
		oo = Integer.MAX_VALUE/2;
		int N = Integer.highestOneBit(n) << 2;
		tree = new Node[N];
		build(1, 0, n - 1);
	}

	private void build(int v, int tl, int tr) {
		if (tl == tr) {
			tree[v] = new Node(-oo, -1);
			return;
		}
		int tm = (tl + tr) >> 1;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);

		tree[v] = merge(tree[2 * v], tree[2 * v + 1]);
	}

	public void update(int pos, int val, int idx) {
		update(1, 0, n - 1, pos, val, idx);
	}

	private void update(int v, int tl, int tr, int pos, int val, int idx) {
		if (tl == tr) {
			tree[v].value = val;
			tree[v].idx = idx;
			return;
		}
		int tm = (tl + tr) >> 1;
		if (pos <= tm) {
			update(2 * v, tl, tm, pos, val, idx);
		}else {
			update(2 * v + 1, tm + 1, tr, pos, val, idx);
		}

		tree[v] = merge(tree[2 * v], tree[2 * v + 1]);
	}

	public Node query(int l, int r) {
		return query(1, 0, n - 1, l, r);
	}

	private Node query(int v, int tl, int tr, int l, int r) {
		if (l > r) return new Node(-oo, -1);
		if (tl == l && tr == r) {
			return tree[v];
		}
		int tm = (tl + tr) >> 1;
		Node left = query(2 * v, tl, tm, l, Math.min(tm, r));
		Node right = query(2 * v + 1, tm + 1, tr, Math.max(l, tm + 1), r);

		return merge(left, right);
	}

	private Node merge(Node left, Node right) {
		if (left == null) return right;
		if (right == null) return left;
		if (left.value > right.value) return left;
		return right;
	}
}
	
class Node {
	int value, idx;
	public Node(int value, int idx) {
		this.value = value;
		this.idx = idx;
	}
}

