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.IOException;
import java.util.TreeMap;
import java.util.InputMismatchException;
import java.util.Set;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author George Marcus
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
    int[] Aint;
    int[] Aidx;
    int val;
    int idx;
    int a, b;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int N = in.nextInt();
        int D = in.nextInt();
        long[] A = new long[N];
        TreeMap<Long, Integer> map = new TreeMap<Long, Integer>();
        for (int i = 0; i < N; i++) {
            A[i] = in.nextLong();
            map.put(A[i], -1);
            map.put(A[i] + D, -1);
            map.put(A[i] - D, -1);
        }
        int cnt = 0;
        int M = map.size(); // M !!!!!!!!!!!!!!!!!!!!!!!
        for (long x : map.keySet()) {
            map.put(x, cnt++);
        }
        Aint = new int[4 * M];
        Aidx = new int[4 * M];

        int[] prev = new int[N];
        for (int i = 0; i < N; i++) {
            int left = map.get(A[i] - D);
            int right = map.get(A[i] + D);
            val = 0;
            idx = -1;
            a = 0; b = left;
            query(1, 0, M - 1);
            a = right; b = M - 1;
            query(1, 0, M - 1);
            prev[i] = idx;
            int crtPos = map.get(A[i]);
            a = crtPos; val = val + 1; b = i;
            update(1, 0, M - 1);
        }

        int ans = Aint[1];
        int k = Aidx[1];

        int[] jumps = new int[ans];
        for (int i = ans - 1; i >= 0; i--) {
            jumps[i] = k + 1;
            k = prev[k];
        }

        out.println(ans);
        for (int i = 0; i < ans; i++) {
            if (i > 0) {
                out.print(" ");
            }
            out.print(jumps[i]);
        }
        out.println();
    }

    private void query(int k, int st, int dr) {
        if (a <= st && dr <= b) {
            if (Aint[k] > val) {
                val = Aint[k];
                idx = Aidx[k];
            }
            return;
        }

        int m = (st + dr) / 2;
        if (a <= m) {
            query(2 * k, st, m);
        }
        if (b > m) {
            query(2 * k + 1, m + 1, dr);
        }
    }

    private void update(int k, int st, int dr) {
        if (st == dr) {
            if (val > Aint[k]) {
                Aint[k] = val;
                Aidx[k] = b;
            }
            return;
        }

        int m = (st + dr) / 2;
        if (a <= m) {
            update(2 * k, st, m);
        }
        else {
            update(2 * k + 1, m + 1, dr);
        }

        if (Aint[2 * k] > Aint[2 * k + 1]) {
            Aint[k] = Aint[2 * k];
            Aidx[k] = Aidx[2 * k];
        }
        else {
            Aint[k] = Aint[2 * k + 1];
            Aidx[k] = Aidx[2 * k + 1];
        }
    }
}

class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(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 int nextInt() {
        return Integer.parseInt(nextString());
    }

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

    public String nextString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuffer res = new StringBuffer();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));

        return res.toString();
    }

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

}

