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 E {

	class Stolb implements Comparable<Stolb> {
		long h;
		int m = -1;
		Stolb next;
		Node w;
		int id;

		public Stolb(long h, int id) {
			this.h = h;
			this.id = id;
		}

		@Override
		public int compareTo(Stolb s) {
			if (m != s.m) {
				return Integer.compare(m, s.m);
			}
			return Long.compare(h, s.h);
		}

	}

	class Node implements Comparable<Node> {
		Stolb s;
		Node p, l, r;
		long f, t;

		Node(Node l, Node r) {
			this.l = l;
			this.r = r;

			f = l.f;
			t = r.t;

			l.p = r.p = this;

			update();
		}

		public Node(Stolb s) {
			this.s = s;
			s.w = this;
			f = t = s.h;
		}

		void update() {
			if (l != r) {
				if (l.s.compareTo(r.s) < 0) {
					s = r.s;
				} else {
					s = l.s;
				}
			}
			if (p != null) {
				p.update();
			}
		}

		Stolb getMax(long from, long to) {
			if (t < from || to < f || to < from) {
				return null;
			}

			if (l == r || from <= f && t <= to) {
				return s;
			}

			return max(l.getMax(from, to), r.getMax(from, to));

		}

		@Override
		public int compareTo(Node n) {
			if (f != n.f) {
				return Long.compare(f, n.f);
			}
			if (t != n.t) {
				return Long.compare(t, n.t);
			}
			return s.compareTo(n.s);
		}

	}

	Stolb max(Stolb a, Stolb b) {
		if (a == null) {
			return b;
		}
		if (b == null) {
			return a;
		}
		if (a.compareTo(b) < 0) {
			return b;
		} else {
			return a;
		}
	}

	void run() throws IOException {
		int n = ni();
		long d = ni();

		long from = 0L, to = 1_000_000_000_000_001L;

		Node[] tree = new Node[n], order = new Node[n];
		for (int i = 0; i < n; i++) {
			tree[i] = order[i] = new Node(new Stolb(Long.parseLong(next()), i + 1));
		}
		Random rnd = new Random();
		for (int i = 2; i < n; i++) {
			int j = rnd.nextInt(i);
			Node temp = tree[i];
			tree[i] = tree[j];
			tree[j] = temp;
		}
		Arrays.sort(tree);
		int size = n;

		while (size > 1) {
			int p = 0;
			for (int i = 1; i < size; i += 2) {
				tree[p++] = new Node(tree[i - 1], tree[i]);
			}

			if (size % 2 == 1) {
				tree[p++] = tree[size - 1];
			}

			size = p;

		}

		for (Node node : order) {
			Stolb s = node.s;
			Stolb m = max(tree[0].getMax(from, s.h - d), tree[0].getMax(s.h + d, to));
			if (m != null && m.m > 0) {
				s.next = m;
				s.m = m.m + 1;
			} else {
				s.m = 1;
			}
			s.w.update();
			// tr(s.id + " " + (s.next == null ? " -1" :
			// Integer.toString(s.next.id)));
		}

		int k = 0;
		Stolb start = null;
		for (Node node : order) {
			Stolb s = node.s;
			if (s.m > k) {
				start = s;
				k = s.m;
			}
		}

		Stack<Stolb> ans = new Stack<Stolb>();
		while (start != null) {
			ans.add(start);
			start = start.next;
		}

		pw.println(ans.size());
		while (!ans.isEmpty()) {
			pw.print(ans.pop().id);
			pw.print(' ');
		}

	}

	int[] na(int a_len) throws IOException {
		int[] _a = new int[a_len];
		for (int i = 0; i < a_len; i++)
			_a[i] = ni();
		return _a;
	}

	int[][] nm(int a_len, int a_hei) throws IOException {
		int[][] _a = new int[a_len][a_hei];
		for (int i = 0; i < a_len; i++)
			for (int j = 0; j < a_hei; j++)
				_a[i][j] = ni();
		return _a;
	}

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

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

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

	void tr(String debug) {
		if (!OJ)
			pw.println(" " + debug);
	}

	static PrintWriter pw;
	static BufferedReader br;
	static StringTokenizer st;
	static boolean OJ;

	public static void main(String[] args) throws IOException {
		long timeout = System.currentTimeMillis();
		OJ = System.getProperty("ONLINE_JUDGE") != null;
		pw = new PrintWriter(System.out);
		br = new BufferedReader(OJ ? new InputStreamReader(System.in) : new FileReader(new File("E.txt")));

		// while (br.ready())
		new E().run();
		if (!OJ) {
			pw.println();
			pw.println(System.currentTimeMillis() - timeout);
		}
		br.close();
		pw.close();
	}

}
