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.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;


public class E {

    static StringTokenizer st;
    static BufferedReader br;
    static PrintWriter pw;
    static class Sort implements Comparable<Sort> {
        long val;
        int ind;
        public int compareTo(Sort arg0) {
            if (this.val > arg0.val)
                return 1;
            if (this.val < arg0.val)
                return -1;
            return this.ind-arg0.ind;
        }
    }
    static int[]t;
    static int INF = (int) 1e9;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int d = nextInt();
        Sort[]a = new Sort[n+1];
        long[]b = new long[n+1], c = new long[n+1];
        for (int i = 1; i <= n; i++) {
            a[i] = new Sort();
            a[i].val = b[i] = nextLong();
            a[i].ind = i;
        }
        Arrays.sort(a, 1, n+1);
        int[]pos = new int[n+1];
        for (int i = 1; i <= n; i++) {
            pos[a[i].ind] = i;
            c[i] = a[i].val;
        }
        t = new int[4*n];
        int[]dp = new int[n+1];
        int last = 0;
        for (int i = 1; i <= n; i++) {
            dp[i] = 1;
            int lower_id = lower_bound(c, n,  b[i]+d);
            if (lower_id != -1) {
                int max = get_max(1, 1, n, lower_id, n);
                dp[i] = Math.max(dp[i], max+1);
            }
            int upper_id = upper_bound(c, n, b[i]-d);
            if (upper_id != -1) {
                int max = get_max(1, 1, n, 1, upper_id);
                dp[i] = Math.max(dp[i], max+1);
            }
            update(1, 1, n, pos[i], dp[i]);
            if (dp[i] > dp[last])
                last = i;
        }
        pw.println(dp[last]);
        ArrayList<Integer> ans = new ArrayList<>();
        ans.add(last);
        for (int i = n; i >= 1; i--) {
            if (dp[i]+1==dp[last] && Math.abs(b[i]-b[last]) >= d) {
                ans.add(i);
                last = i;
            }
        }
        Collections.reverse(ans);
        for (int i : ans) {
            pw.print(i+" ");
        }
        pw.println();
        pw.close();
    }
    private static void update(int v, int tl, int tr, int ind, int new_val) {
        if (tl==tr)
            t[v] = new_val;
        else {
            int tm = (tl+tr) >> 1;
            if (ind <= tm)
                update(2*v, tl, tm, ind, new_val);
            else
                update(2*v+1, tm+1, tr, ind, new_val);
            t[v] = Math.max(t[2*v], t[2*v+1]);
        }
    }
    private static int get_max(int v, int tl, int tr, int L, int R) {
        if (L > R)
            return -INF;
        if (tl==L && tr==R)
            return t[v];
        int tm = (tl+tr) >> 1;
        return Math.max(get_max(2*v, tl, tm, L, Math.min(tm, R)), get_max(2*v+1, tm+1, tr, Math.max(L, tm+1), R));
    }
    private static int upper_bound(long[] c, int n, long x) {
        int L = 1, R = n+1;
        while (R-L > 1) {
            int m = (L+R) >> 1;
            if (c[m] <= x)
                L = m;
            else
                R = m;
        }
        if (c[L] <= x)
            return L;
        return -1;
    }
    private static int lower_bound(long[] c, int n, long x) {
        int L = 0, R = n;
        while (R-L > 1) {
            int m = (L+R) >> 1;
            if (c[m] >= x)
                R = m;
            else
                L = m;
        }
        if (c[R] >= x)
            return R;
        return -1;
    }
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}
