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.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.concurrent.LinkedBlockingDeque;

import javax.swing.border.Border;

public class a {

	public static long mod = (long) Math.pow(10, 9) + 7;
	public static int k = 0;

	private static class node implements Comparable<node> {
		int l;
		int r;
		int index;
		int index2;
		int buffer;

		node(int l, int r, int i, int b, int i2) {
			this.l = l;
			this.r = r;
			index = i;
			buffer = b;
			index2 = i2;

		}

		@Override
		public int compareTo(node o) {
			if (k == 0) {
				if (o.l < l)
					return 1;
				else if (o.l > l)
					return -1;
				else if (o.buffer != -1) {
					return 1;
				} else
					return -1;
			} else if (k == 1) {
				if (r != o.r)
					return r - o.r;
				return o.index - index;
			} else if (k == 2) {
				return r - o.r;
			} else {
				if (o.index < index)
					return 1;
				else
					return -1;
			}

		}
	}

	// private static class point implements Comparable<point> {
	// int l;
	// int r;
	// int index;
	// int buffer;
	//
	// point(int l, int r, int i, int b) {
	// this.l = l;
	// this.r = r;
	// index = i;
	// buffer = b;
	//
	// }
	//
	// @Override
	// public int compareTo(point o) {
	// if (o.l < l)
	// return 1;
	// else if (o.l > l)
	// return -1;
	// else if (o.r < r)
	// return 1;
	// else if (o.r > r)
	// return -1;
	// return 0;
	// }
	//
	// }

	public static class point implements Comparable<point> {
		long x;
		long y;
		long b;

		point(long x, long y, long b) {
			this.x = x;
			this.y = y;
			this.b = b;
		}

		@Override
		public int compareTo(point o) {
			if (k == 0)
				return (int) (o.x - x);
			else
				return (int) (y - o.y);

		}
	}

	public static int ch(long y) {
		int r = Long.bitCount(y);
		return r;
	}

	public static long gcd(long x, long y) {
		if (y == 0)
			return x;

		return gcd(y, x % y);
	}

	public static int min[];
	public static int max[];

	public static void build(int s, int e, int p, int a[]) {
		if (s == e) {
			min[p] = a[s];
			max[p] = a[s];
			return;
		}

		int mid = (s + e) / 2;
		build(s, mid, p * 2, a);
		build(mid + 1, e, p * 2 + 1, a);
		min[p] = Math.min(min[p * 2], min[p * 2 + 1]);
		max[p] = Math.max(max[p * 2], max[p * 2 + 1]);
	}

	public static int getMin(int s, int e, int p, int from, int to) {
		if (s > to || e < from)
			return Integer.MAX_VALUE;
		if (s >= from && e <= to)
			return min[p];
		int mid = (s + e) / 2;

		int a = getMin(s, mid, p * 2, from, to);
		int b = getMin(mid + 1, e, p * 2 + 1, from, to);
		return Math.min(a, b);

	}

	public static int getMax(int s, int e, int p, int from, int to) {
		if (s > to || e < from)
			return Integer.MIN_VALUE;
		if (s >= from && e <= to)
			return max[p];
		int mid = (s + e) / 2;

		int a = getMax(s, mid, p * 2, from, to);
		int b = getMax(mid + 1, e, p * 2 + 1, from, to);
		return Math.max(a, b);

	}

	public static boolean ch[];
	public static ArrayList<Integer> prime;
	public static Queue<Integer> pp;

	public static void sieve(int k) {
		ch[0] = ch[1] = true;

		for (int i = 2; i <= k; i++) {
			if (!ch[i]) {
				prime.add(i);
				pp.add(i);
				for (int j = i + i; j <= k; j += i) {
					ch[j] = true;
				}
			}
		}

	}

	public static int sort(int a[], int st, int end) {
		for (int i = st; i < end - 1; i++) {
			if (a[i] > a[i + 1])
				return i + 1;
		}
		return -1;
	}

	public static long seg1[];
	public static long seg2[];
	public static long lazy1[];
	public static long lazy2[];

	public static void update(int s, int e, int p, long seg[], long lazy[],
			int from, int to, long val) {
		if (lazy[p] != 0) {
			seg[p] = Math.max(seg[p], lazy[p]);
			if (s != e) {
				lazy[p * 2] = Math.max(lazy[p], lazy[p * 2]);
				lazy[p * 2 + 1] = Math.max(lazy[p], lazy[p * 2 + 1]);
			}
			lazy[p] = 0;
		}
		if (s > to || e < from)
			return;

		if (s >= from && e <= to) {

			seg[p] = Math.max(seg[p], val);
			if (s != e) {
				lazy[p * 2] = Math.max(val, lazy[p * 2]);
				lazy[p * 2 + 1] = Math.max(val, lazy[p * 2 + 1]);
			}

			return;
		}

		int mid = (s + e) / 2;
		update(s, mid, p * 2, seg, lazy, from, to, val);
		update(mid + 1, e, p * 2 + 1, seg, lazy, from, to, val);
		seg[p] = Math.max(seg[p * 2], seg[p * 2 + 1]);

	}

	public static long get(int s, int e, int p, long seg[], long lazy[],
			int from, int to) {
		if (lazy[p] != 0) {
			seg[p] = Math.max(seg[p], lazy[p]);
			if (s != e) {
				lazy[p * 2] = Math.max(lazy[p], lazy[p * 2]);
				lazy[p * 2 + 1] = Math.max(lazy[p], lazy[p * 2 + 1]);
			}
			lazy[p] = 0;
		}
		if (s > to || e < from)
			return Long.MIN_VALUE;

		if (s >= from && e <= to) {
			return seg[p];
		}
		int mid = (s + e) / 2;
		long a = get(s, mid, p * 2, seg, lazy, from, to);
		long b = get(mid + 1, e, p * 2 + 1, seg, lazy, from, to);
		return Math.max(a, b);

	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder qq = new StringBuilder();
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		String y[] = in.readLine().split(" ");
		int n = Integer.parseInt(y[0]);
		int d = Integer.parseInt(y[1]);
		long arr[] = new long[n];
		Long sorted[] = new Long[n];
		seg1 = new long[n * 4];
		seg2 = new long[n * 4];
		lazy1 = new long[n * 4];
		lazy2 = new long[n * 4];
		y = in.readLine().split(" ");
		for (int i = 0; i < n; i++) {
			arr[i] = Long.parseLong(y[i]);
			sorted[i] = arr[i];
		}
		Arrays.sort(sorted);
		HashMap<Long, Integer> mp = new HashMap();
		for (int i = 0; i < n; i++)
			if (!mp.containsKey(sorted[i]))
				mp.put(sorted[i], i + 1);

		TreeSet<Long> tree = new TreeSet();
		long maximum = 0;
		long size[] = new long[n];
		for (int i = 0; i < n; i++) {
			long elem1 = arr[i] + d;
			long elem2 = arr[i] - d;
			Long one = tree.ceiling(elem1);
			Long two = tree.floor(elem2);

			long max = 0;
			if (one != null) {
				int index1 = mp.get(one);
				long g1 = get(1, n, 1, seg1, lazy1, index1, n);
				
				max = Math.max(max, g1);
			}
			if (two != null) {
				int index2 = mp.get(two);
				long g1 = get(1, n, 1, seg1, lazy1, 1, index2);

				max = Math.max(max, g1);
			}
			size[i] = max + 1;
			maximum = Math.max(maximum, size[i]);
			//System.out.println(arr[i] + " " + size[i]);
			tree.add(arr[i]);
			update(1, n, 1, seg1, lazy1, mp.get(arr[i]), mp.get(arr[i]), size[i]);
			// update(1, n, 1, seg2, lazy2, 1, mp.get(arr[i]), size[i]);

		}
		//System.out.println(Arrays.toString(size));
		Stack<Integer> s = new Stack<>();
		long r = maximum;
		long w = -1;
		
		for (int i = n - 1; i >= 0; i--) {
			
			if (size[i] == r && (Math.abs(w - arr[i]) >= d || w == -1)) {
				s.add(i + 1);
				w = arr[i];
				r--;
			}
		}
		qq.append(s.size()+"\n");
		while(!s.isEmpty()){
			qq.append(s.pop()+" ");
		}
		System.out.println(qq);

	}
	
	/*
	 * 139 9251
44243 43803 31356 25085 37429 40103 16225 16828 11148 1052 39431 20858 7018 14692 28388 32588 26498 25148 29777 15299 41387 11500 11246 10537 23289 40449 7780 2521 34574 35306 42224 22506 3036 40157 16 3131 29509 8851 26481 13779 19050 40537 7494 27005 7880 45546 30797 7650 10785 21193 22252 43185 10451 44252 31223 3421 19196 33816 39279 19663 6546 1761 24753 1344 866 46085 13446 42731 44 45374 19905 16142 22155 19184 20464 31176 28168 19368 17906 38706 44447 29519 16841 27338 35425 9257 23284 9492 10270 39594 11003 1763 45656 37030 9379 14648 37190 7421 33036 4881 23670 27478 22146 8392 4751 29303 13763 33914 51 8317 572 39044 15370 35695 13201 39251 27749 26497 21615 15681 40947 6501 23777 35473 9741 10329 21315 38999 43574 41601 35167 2710 3685 1320 17143 26649 17767 44257 7646
	 * 
	 */
}