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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

/**
 * @author Don Li
 */
public class Pillars {

    int n, d;
    long[] h;
    Map<Long, Integer> ids = new HashMap<>();

    void solve() {
        n = in.nextInt();
        d = in.nextInt();
        h = new long[n];
        for (int i = 0; i < n; i++) h[i] = in.nextLong();

        compress();

        int m = ids.size();
        SegmentTreeRMQ rmq = new SegmentTreeRMQ(m);

        int max = 0, id = -1;
        int[] dp = new int[n];
        for (int i = n - 1; i >= 0; i--) {
            int l = ids.get(h[i] - d), r = ids.get(h[i] + d);
            dp[i] = 1 + Math.max(rmq.query(0, l + 1), rmq.query(r, m));
            rmq.update(ids.get(h[i]), dp[i]);
            if (max < dp[i]) {
                max = dp[i];
                id = i;
            }
        }

        out.println(max);
        int cur = id;
        while (max-- > 0) {
            if (cur != id) out.print(' ');
            out.print(cur + 1);
            int nxt = cur + 1;
            while (nxt < n) {
                if (Math.abs(h[cur] - h[nxt]) >= d && dp[cur] == dp[nxt] + 1) break;
                nxt++;
            }
            cur = nxt;
        }
    }

    void compress() {
        Set<Long> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            set.add(h[i] - d);
            set.add(h[i]);
            set.add(h[i] + d);
        }
        List<Long> sorted = new ArrayList<>(set);
        Collections.sort(sorted);

        int cnt = 0;
        for (Long v : sorted) {
            ids.put(v, cnt++);
        }
    }

    static class SegmentTreeRMQ {
        int n;
        int[] d;

        SegmentTreeRMQ(int m) {
            int x = 0;
            while ((1 << x) < m) x++;
            n = 1 << x;
            d = new int[2 * n - 1];
        }

        void update(int i, int v) {
            i += n - 1;
            d[i] = v;
            while (i > 0) {
                i = (i - 1) / 2;
                d[i] = Math.max(d[2 * i + 1], d[2 * i + 2]);
            }
        }

        int query(int a, int b) {
            return query(a, b, 0, 0, n);
        }

        private int query(int a, int b, int k, int l, int r) {
            if (a >= r || b <= l) return 0;
            if (a <= l && b >= r) return d[k];
            return Math.max(query(a, b, 2 * k + 1, l, (l + r) / 2), query(a, b, 2 * k + 2, (l + r) / 2, r));
        }
    }

    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new Pillars().solve();
        out.close();
    }

    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }

        public long nextLong() {
            return Long.parseLong(nextToken());
        }

        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
