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.lang.reflect.Array;
import java.util.*;

public class Main {
    private static FastInput fin;
    private static InputReader in;
    private static PrintWriter out;
    private static Scanner input;
    private static Pair[] tree;
//    private static StringBuilder stringBuilder;
    
    public static void main(String[] args) throws IOException {
        fin = new FastInput();
        in = new InputReader();
        input = new Scanner(System.in);
        out = new PrintWriter(System.out);
//        stringBuilder = new StringBuilder();
        int t = 1;
//        t = reader.nextInt();
        for (int i = 0; i < t; ++i) {
            solve();
        }
        out.close();
    }
    
    private static void solve() throws IOException {
        int n = in.nextInt();
        long h = in.nextLong();
        long[] a = new long[n];
        long[] b = new long[n];
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextLong();
            b[i] = a[i];
        }
        Arrays.sort(a);
        tree = new Pair[(int) (5 * 1e5)];
        for (int i = 0; i < tree.length; ++i) tree[i] = new Pair(Integer.MIN_VALUE, Integer.MIN_VALUE);
        a = unique(a);
        HashMap<Long, Integer> position = new HashMap<>();
        HashMap<Long, Pair> rng = new HashMap<>();
        for (int i = 0; i < a.length; ++i) {
            position.put(a[i], i);
            rng.put(a[i], new Pair(getLeft(a[i], h, a, i), getRight(a[i], h, a, i)));
        }
//        out.println(rng);
        int N = a.length;
        int[] pathSize = new int[n];
        int[] from = new int[n];
        for (int i = 0; i < n; ++i) {
            int currentPos = position.get(b[i]);
            int L = rng.get(b[i]).idx, R = rng.get(b[i]).val;
            Pair leftBest = L == -1 ? new Pair(Integer.MIN_VALUE, Integer.MIN_VALUE) : query(0, 0, N - 1, 0, L);
            Pair rightBest = R == -1 ? new Pair(Integer.MIN_VALUE, Integer.MIN_VALUE) : query(0, 0, N - 1, R, N - 1);
            Pair currentBest = leftBest;
            if (rightBest.val >= leftBest.val) currentBest = rightBest;
            if (currentBest.val == Integer.MIN_VALUE) {
                pathSize[i] = 1;
                from[i] = -1;
                update(0, 0, N, currentPos, new Pair(i, 1));
            } else {
                pathSize[i] = currentBest.val + 1;
                from[i] = currentBest.idx;
                update(0, 0, N - 1, currentPos, new Pair(i, currentBest.val + 1));
            }
        }
        int idx = -1, max = Integer.MIN_VALUE;
        for (int i = 0; i < n; ++i) {
            if (max < pathSize[i]) {
                max = pathSize[i];
                idx = i;
            }
        }
        out.println(max);
        ArrayList<Integer> path = new ArrayList<>();
        while (idx != -1) {
            path.add(idx + 1);
            idx = from[idx];
        }
        Collections.reverse(path);
        for (int e : path) out.print(e + " ");
    }
    
    private static void update(int node, int start, int end, int idx, Pair value) {
        if (start == end) {
            tree[node] = new Pair(value);
            return;
        }
        int mid = (start + end) >> 1;
        if (idx <= mid) update(2 * node + 1, start, mid, idx, value);
        else update(2 * node + 2, mid + 1, end, idx, value);
        if (tree[2 * node + 1].val >= tree[2 * node + 2].val) {
            tree[node] = new Pair(tree[2 * node + 1]);
        } else {
            tree[node] = new Pair(tree[2 * node + 2]);
        }
    }
    
    private static Pair query(int node, int start, int end, int l, int r) {
        if (start > r || end < l) return new Pair(Integer.MIN_VALUE, Integer.MIN_VALUE);
        if (l <= start && end <= r) return tree[node];
        int mid = (start + end) >> 1;
        Pair left = query(2 * node + 1, start, mid, l, r);
        Pair right = query(2 * node + 2, mid + 1, end, l, r);
        if (left.val >= right.val) return left;
        return right;
    }
    
    private static long[] unique(long[] a) {
        ArrayList<Long> v = new ArrayList<>();
        v.add(a[0]);
        for (int i = 1; i < a.length; ++i)
            if (a[i] != a[i - 1]) {
                v.add(a[i]);
            }
        long[] res = new long[v.size()];
        for (int i = 0; i < v.size(); ++i) res[i] = v.get(i);
        return res;
    }
    
    private static int getRight(long curr, long h, long[] a, int pos) {
        int low = pos, high = a.length - 1, at = -1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (a[mid] - curr >= h) {
                at = mid;
                high = mid - 1;
            } else low = mid + 1;
        }
        return at;
    }
    
    private static int getLeft(long curr, long h, long[] a, int pos) {
        int low = 0, high = pos, at = -1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (curr - a[mid] >= h) {
                at = mid;
                low = mid + 1;
            } else high = mid - 1;
        }
        return at;
    }
    
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
        
        public InputReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }
        
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        int nextInt() {
            return Integer.parseInt(next());
        }
        
        long nextLong() {
            return Long.parseLong(next());
        }
        
        double nextDouble() {
            return Double.parseDouble(next());
        }
        
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    
    static class FastInput {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
        
        public FastInput() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        
        public FastInput(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
        
        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        
        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            
            if (neg)
                return -ret;
            return ret;
        }
        
        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
        
        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
            
            if (neg)
                return -ret;
            return ret;
        }
        
        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
        
        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
        
        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }
    
    static class Pair {
        int idx, val;
        
        public Pair(int idx, int val) {
            this.idx = idx;
            this.val = val;
        }
        
        public Pair(Pair P) {
            this.idx = P.idx;
            this.val = P.val;
        }
        
        @Override
        public String toString() {
            return "{" + idx +
                    ", " + val +
                    '}';
        }
    }
}