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.
#include <bits/stdc++.h>
using namespace std;
long long h[100003], hh[100003];
int cnt[100003], f[100003], tree[400003], father[400003];
stack<int> st;
void build(int k, int l, int r) {
  if (l == r)
    tree[k] = 0, father[k] = l;
  else {
    int mid = (l + r) / 2;
    build(2 * k, l, mid);
    build(2 * k + 1, mid + 1, r);
    tree[k] = 0, father[k] = l;
  }
}
void update(int k, int l, int r, int pos, int x, int y) {
  if (l == r && l == pos)
    tree[k] = x, father[k] = y;
  else {
    int mid = (l + r) / 2;
    if (pos <= mid) update(2 * k, l, mid, pos, x, y);
    if (pos > mid) update(2 * k + 1, mid + 1, r, pos, x, y);
    if (tree[2 * k] > tree[2 * k + 1]) {
      tree[k] = tree[2 * k];
      father[k] = father[2 * k];
    } else {
      tree[k] = tree[2 * k + 1];
      father[k] = father[2 * k + 1];
    }
  }
}
pair<int, int> query(int k, int l, int r, int l0, int r0) {
  if (l0 <= l && r <= r0)
    return make_pair(tree[k], father[k]);
  else {
    int mid = (l + r) / 2;
    pair<int, int> res1, res2;
    res1.first = res2.first = 0;
    if (l0 <= mid) res1 = query(2 * k, l, mid, l0, r0);
    if (mid < r0) res2 = query(2 * k + 1, mid + 1, r, l0, r0);
    if (res1 > res2)
      return res1;
    else
      return res2;
  }
}
int main() {
  int n, d;
  scanf("%d%d", &n, &d);
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &h[i]);
    hh[i] = h[i];
    f[i] = i;
  }
  sort(hh + 1, hh + n + 1);
  hh[0] = 0;
  build(1, 1, n);
  for (int i = 1; i <= n; i++) {
    long long l = h[i] - d;
    int pl = upper_bound(hh, hh + n + 1, l) - hh - 1;
    long long r = h[i] + d;
    int pr = lower_bound(hh, hh + n + 1, r) - hh;
    int pos = lower_bound(hh, hh + n + 1, h[i]) - hh;
    pair<int, int> res;
    if (pl >= 1) {
      if (pr <= n)
        res = max(query(1, 1, n, 1, pl), query(1, 1, n, pr, n));
      else
        res = query(1, 1, n, 1, pl);
      cnt[i] = res.first + 1;
      if (cnt[i] > 1) f[i] = res.second;
      update(1, 1, n, pos, cnt[i], i);
    } else if (pr <= n) {
      res = query(1, 1, n, pr, n);
      cnt[i] = res.first + 1;
      if (cnt[i] > 1) f[i] = res.second;
      update(1, 1, n, pos, cnt[i], i);
    }
  }
  int maxx = 0, pos;
  for (int i = 1; i <= n; i++)
    if (cnt[i] > maxx) pos = i, maxx = cnt[i];
  int p = pos;
  while (f[p] != p) {
    st.push(p);
    p = f[p];
  }
  printf("%d\n%d", cnt[pos], p);
  while (st.size()) {
    printf(" %d", st.top());
    st.pop();
  }
  return 0;
}
