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

public class Main {
	public static void main(String[] args) throws Exception {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		new Task().solve(1,in,out);
		out.close();
	}
}

class Task {
	void solve(int ca,Scanner in,PrintWriter out) {
		int n = in.nextInt();
		long D = in.nextLong();
		long[] A = new long[n];
		San ss = new San(n);
		for (int i = 0; i < n; ++ i) {
			A[i] = in.nextLong();
			ss.push(A[i]);
		}
		ss.doit();
		int[] pre = new int[n];
		Arrays.fill(pre,-1);
		Tree tree = new Tree();
		tree.build(0,ss.n);
		int answer = 0,Index = -1;
		for (int i = 0; i < n; ++ i) {
			int a = ss.upper_bound(A[i]-D)-1;
			int b = ss.lower_bound(A[i]+D);
			Pair t = tree.query(0,a).max(tree.query(b,ss.n));
			if (t.x > 0) {
				pre[i] = (int)t.y;
			}
			if (t.x+1 > answer) {
				answer = (int)t.x+1;
				Index = i;
			}
			tree.modify(ss.lower_bound(A[i]),new Pair(t.x+1,i));
		}
		out.println(answer);
		int[] stack = new int[n];
		int top = 0;
		for (int i = Index; i != -1; i = pre[i]) {
			stack[top++] = i;
		}
		for (int i = top-1; i >= 0; -- i) {
			out.print((stack[i]+1) + " ");
		}
		out.println();
	}

	class Tree {
		Tree lc,rc;
		int l,r;
		Pair val;
		void build(int l,int r) {
			this.l = l;
			this.r = r;
			val = new Pair(0,-1);
			if (l == r) return ;
			lc = new Tree();
			rc = new Tree();
			int mid = l+r>>1;
			lc.build(l,mid);
			rc.build(mid+1,r);
		}
		Pair query(int L,int R) {
			if (r<L || R<l) return new Pair(0,-1);
			if (L<=l && r<=R) return val.copy();
			return lc.query(L,R).max(rc.query(L,R));
		}
		void modify(int p,Pair val) {
			if (p<l || r<p) return ;
			if (l == r) {
				this.val = val;
				return ;
			}
			lc.modify(p,val);
			rc.modify(p,val);
			this.val = lc.val.max(rc.val).copy();
		}
	}

	class Pair implements Comparable<Pair> {
		long x,y;
		Pair(long x,long y) {
			this.x = x;
			this.y = y;
		}
		public int compareTo(Pair t) {
			if (x<t.x || x==t.x && y<t.y) return -1;
			if (x==t.x && y==t.y) return 0;
			return 1;
		}
		Pair copy() {
			return new Pair(x,y);
		}
		Pair max(Pair t) {
			int res = this.compareTo(t);
			if (res >= 0) return this;
			return t;
		}
	}

	class San {
		long[] A;
		int n;
		San(int n) {
			A = new long[n];
		}
		void push(long x) {
			A[n++] = x;
		}
		void doit() {
			Arrays.sort(A,0,n);
			int t = 1;
			for (int i = 1; i < n; ++ i) {
				if (A[i]==A[i-1]) continue;
				A[t++] = A[i];
			}
			n = t;
		}
		int lower_bound(long x) {
			int l = 0,r = n-1;
			while (l <= r) {
				int mid = l+r>>1;
				if (A[mid]>=x) {
					r = mid-1;
				} else {
					l = mid+1;
				}
			}
			return r+1;
		}
		int upper_bound(long x) {
			int l = 0,r = n-1;
			while (l <= r) {
				int mid = l+r>>1;
				if (A[mid]>x) {
					r = mid-1;
				} else {
					l = mid+1;
				}
			}
			return r+1;
		}
	}
}
