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 {
    public static void main(String[] args) throws Exception {

        new E().solve();
    }

    void solve() throws IOException {
        FastScanner in = new FastScanner(System.in);

        long INF = Integer.MAX_VALUE / 2;
        int n = in.nextInt();
        int d = in.nextInt();

        int[] next = new int[n];
        long[] h = new long[n];
        long[] hs = new long[n];
        for (int i = 0; i < n; i++) {
            hs[i] = h[i] = in.nextLong();
        }
        Arrays.sort(hs);
        int[] p = new int[n];
        for (int i = 0; i < n; i++) {
            p[i] = Arrays.binarySearch(hs, h[i]);
        }

        int max = 0;
        int mi = 0;
        seg = new long[n * 4];
        for (int i = n - 1; i >= 0; i--) {
            int ai = Arrays.binarySearch(hs, h[i]);
            long sv = get(ai);
            next[i] = (int) (sv % INF);
            int cnt = (int) (sv / INF) + 1;
            long v = cnt * INF + i;

            long h1 = h[i] - d;
            int i1 = Arrays.binarySearch(hs, h1);
            if (i1 < 0) {
                i1 = -i1 - 1 - 1;
            }
            if (i1 >= 0) {
                update(0, i1, v);
            }
            long h2 = h[i] + d;
            int i2 = Arrays.binarySearch(hs, h2);
            if (i2 < 0) {
                i2 = -i2 - 1;
            }
            if (i2 < n) {
                update(i2, n - 1, v);
            }

            if (max < cnt) {
                max = cnt;
                mi = i;
            }
        }

        System.out.println(max);
        StringBuilder sb = new StringBuilder();
        sb.append((mi + 1));
        while ((mi = next[mi]) != 0) {
            sb.append(" " + (mi + 1));
        }

        System.out.print(sb);

    }
    long[] seg;
    void update(int ali, int ari, long v) {
        update(ali, ari, v, 0, 0, seg.length / 4);
    }
    void update(int ali, int ari, long v, int si, int sli, int len) {

        int sri = sli + len - 1;
        if (ali <= sli && sri <= ari) {
            seg[si] = Math.max(seg[si], v);
        } else if (sri < ali || ari < sli) {
            //
        } else {
            int mi = sli + len / 2;
            update(ali, ari, v, 2 * si + 1, sli, len / 2);
            update(ali, ari, v, 2 * si + 2, mi, len - len / 2);
        }
    }
    long get(int ai) {
        return get(ai, 0, 0, seg.length / 4);
    }
    long get(int ai, int si, int sli, int len) {
        if (len == 1) {
            return seg[si];
        } else {
            int mi = sli + len / 2;
            if (ai < mi) {
                return Math.max(seg[si], get(ai, 2 * si + 1, sli, len / 2));
            } else {
                return Math.max(seg[si], get(ai, 2 * si + 2, mi, len - len / 2));
            }
        }
    }




    class FastScanner {

        private InputStream _stream;
        private byte[] _buf = new byte[1024];
        private int _curChar;
        private int _numChars;
        private StringBuilder _sb = new StringBuilder();

        FastScanner(InputStream stream) {
            this._stream = stream;
        }

        public 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++];
        }

        public String next() {
            int c = read();
            while (isWhitespace(c)) {
                c = read();
            }
            _sb.setLength(0);
            do {
                _sb.appendCodePoint(c);
                c = read();
            } while (!isWhitespace(c));
            return _sb.toString();
        }

        public int nextInt() {
            return (int) nextLong();
        }
        public long nextLong() {
            int c = read();
            while (isWhitespace(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 (!isWhitespace(c));
            return res * sgn;
        }

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

}

//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
