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.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.math.BigInteger;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

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

class TaskE {
    Scanner in;
    PrintWriter out;

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        this.in = in;
        this.out = out;
        run();
    }

    void run() {
        int n = in.nextInt();
        long d = in.nextInt();
        long[] is = in.nextLongArray(n);
        V[] dp = new V[n];
        dp[0] = new V(1, -1);
        T t = new T(is[0], new V(1, 0));
        for (int i = 1; i < n; i++) {
            dp[i] = new V(1, -1);
            T[] ts = splitKey(t, is[i] - d);
            if (ts[0] != NULL) {
                V v = ts[0].max;
                if (dp[i].val < v.val + 1) {
                    dp[i].val = v.val + 1;
                    dp[i].id = v.id;
                }
            }
            T[] ts1 = splitKey(ts[1], is[i] + d - 1);
            if (ts1[1] != NULL) {
                V v = ts1[1].max;
                if (dp[i].val < v.val + 1) {
                    dp[i].val = v.val + 1;
                    dp[i].id = v.id;
                }
            }
            t = merge(ts[0], merge(ts1[0], ts1[1]));
            if (dp[i].val > 0) t = add(t, is[i], new V(dp[i].val, i));
        }
        int first = 0;
        for (int i = 0; i < n; i++) {
            if (dp[i].val > dp[first].val) first = i;
        }
        int cnt = dp[first].val;
        out.println(cnt);
        int[] ps = new int[cnt];
        for (int i = 0; i < cnt; i++) {
            ps[cnt - i - 1] = first;
            first = dp[first].id;
        }
        for (int i = 0; i < cnt; i++) {
            out.print((ps[i] + 1) + " ");
        }
        out.println();
    }

    private T add(T t, long k, V v) {
        T[] ts = splitKey(t, k);
        T[] ts0 = splitKey(ts[0], k - 1);
        if (ts0[1] == NULL) return merge(ts0[0], merge(new T(k, v), ts[1]));
        ts0[1].val = max(ts0[1].val, v);
        ts0[1].max = ts0[1].val;
        return merge(merge(ts0[0], ts0[1]), ts[1]);
    }

    class V {
        int val;
        int id;

        V(int val, int id) {
            this.val = val;
            this.id = id;
        }
    }

    V max(V a, V b) {
        if (a.val > b.val) return a;
        return b;
    }

    class T {
        long key;
        V val;
        V max;
        int size;
        double p;
        T left;
        T right;

        T(long key, V val, int size, double p, T left, T right) {
            this.key = key;
            this.val = val;
            this.max = val;
            this.size = size;
            this.p = p;
            this.left = left;
            this.right = right;
        }

        T(long key, V val) {
            this(key, val, 1, Math.random(), NULL, NULL);
        }

        T change(T left, T right) {
            size = left.size + right.size + 1;
            max = max(max(left.max, right.max), val);
            this.left = left;
            this.right = right;
            return this;
        }

        T push() {
            if (this != NULL) {

            }
            return this;
        }
    }

    T NULL = new T(0, new V(-12341234, -1), 0, 0, null, null);

    T[] splitKey(T t, long key) {
        T[] res;
        if (t == NULL) {
            res = new T[] { NULL, NULL };
        } else if (key < t.push().key) {
            res = splitKey(t.left, key);
            res[1] = t.change(res[1], t.right);
        } else {
            res = splitKey(t.right, key);
            res[0] = t.change(t.left, res[0]);
        }
        return res;
    }

    T merge(T t1, T t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        if (t1.p < t2.p) return t1.push().change(t1.left, merge(t1.right, t2));
        return t2.push().change(merge(t1, t2.left), t2.right);
    }

}

class Scanner {
    BufferedReader br;
    StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        eat("");
    }

    private void eat(String s) {
        st = new StringTokenizer(s);
    }

    public String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public boolean hasNext() {
        while (!st.hasMoreTokens()) {
            String s = nextLine();
            if (s == null)
                return false;
            eat(s);
        }
        return true;
    }

    public String next() {
        hasNext();
        return st.nextToken();
    }

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

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

    public long[] nextLongArray(int n) {
        long[] ls = new long[n];
        for (int i = 0; i < n; i++) {
            ls[i] = nextLong();
        }
        return ls;
    }

}

