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

public class TestClass {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	
	static long a[] = new long[1000000];
	static int pre[];
	public static  void insert(int l,int r,int counter,long index,long val){
		if(l>=r){
			a[counter] = (val<<32)|index;
			return ;
		}
		int mid = (l+r)>>1;
		if(mid>=index)
			insert(l,mid,2*counter+1,index,val);
		else
			insert(mid+1,r,2*counter+2,index,val);
		a[counter] = Math.max(a[2*counter+1], a[2*counter+2]);
	}
	public static long getMax(int l,int r,int coun,int x,int y){
		if(x<=l&&y>=r)
			return a[coun];
		if(l>r||x>y||l>y||x>r)
			return 0;
		int mid = (l+r)>>1;
		return Math.max(getMax(l,mid,2*coun+1,x,y), getMax(mid+1,r,2*coun+2,x,y));
	}
	private static void soln() {
		int n = nI(),d = nI();
		pre = new int[n];
		long arr[] = new long[n];
		long dup[] = new long[n];
		for(int i=0;i<n;i++)
			arr[i] = nL();
		dup = Arrays.copyOf(arr, n);
		Arrays.sort(dup);
		int cou = 0;
		for(int i=0;i<n;i++)
			if(i==0||dup[i]!=dup[i-1])
				dup[cou++] = dup[i];
		dup = Arrays.copyOf(dup, cou);
		int mv=0,mi=0;
		HashMap<Long,Integer> map = new HashMap<Long,Integer>();
		for(int i=0;i<n;i++){
			int min = Arrays.binarySearch(dup, arr[i]-d),max = Arrays.binarySearch(dup,arr[i]+d);
			if(min<0)
				min = -min-2;
			if(max<0)
				max = -max-1;
			long temp = Math.max(getMax(0,cou-1,0,0,min), getMax(0,cou-1,0,max,cou-1));
			int in = Arrays.binarySearch(dup,arr[i]);
			if((temp>>32)==0)
				pre[i] = i;
			else
				pre[i] = map.get(dup[(int)temp]);
			map.put(arr[i], i);
			insert(0,cou-1,0,in,(temp>>32)+1);
			if(mv<(temp>>32)+1){
				mv = (int)((temp>>32)+1);
				mi = i;
			}
		}
		pw.println(mv);
		TreeSet<Integer> set = new TreeSet<Integer>();
		while(mi!=pre[mi]){
			set.add(mi);
			mi = pre[mi];
		}
		set.add(pre[mi]);
		while(!set.isEmpty())
			pw.print((set.pollFirst()+1)+" ");
	}

	public static void main(String[] args) {
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		soln();
		pw.close();
	}

	// To Get Input
	// Some Buffer Methods
	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private static int nI() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static long nL() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nLi() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}