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;
const int MAXN = 1e5 + 5;
const int inf = 0x3f3f3f3f;
int n;
long long d;
long long a[MAXN];
long long tmp[MAXN * 3];
int top = 0;
int ID(long long x) { return lower_bound(tmp, tmp + top, x) - tmp + 1; }
struct Node {
  int len, id;
  bool operator<(const Node &that) const { return len < that.len; }
};
struct Seg {
  Node tree[MAXN * 12];
  void pushUp(int x) {
    if (tree[x * 2 + 1] < tree[x * 2]) {
      tree[x].len = tree[x * 2].len;
      tree[x].id = tree[x * 2].id;
    } else {
      tree[x].len = tree[x * 2 + 1].len;
      tree[x].id = tree[x * 2 + 1].id;
    }
  }
  void Build(int l, int r, int x) {
    if (l == r) {
      tree[x].len = 0;
      tree[x].id = -1;
      return;
    }
    int mid = (l + r) / 2;
    Build(l, mid, x * 2);
    Build(mid + 1, r, x * 2 + 1);
    pushUp(x);
  }
  void Modify(int idx, int idx2, int val, int l, int r, int x) {
    if (l == r) {
      if (tree[x].len < val) {
        tree[x].len = val;
        tree[x].id = idx2;
      }
      return;
    }
    int mid = (l + r) / 2;
    if (idx <= mid)
      Modify(idx, idx2, val, l, mid, x * 2);
    else
      Modify(idx, idx2, val, mid + 1, r, x * 2 + 1);
    pushUp(x);
  }
  Node Query(int L, int R, int l, int r, int x) {
    if (L == l && R == r) {
      return tree[x];
    }
    int mid = (l + r) / 2;
    if (R <= mid) {
      return Query(L, R, l, mid, x * 2);
    } else if (L > mid) {
      return Query(L, R, mid + 1, r, x * 2 + 1);
    } else {
      return max(Query(L, mid, l, mid, x * 2),
                 Query(mid + 1, R, mid + 1, r, x * 2 + 1));
    }
  }
} seg;
int pre[MAXN];
void print(int x) {
  if (pre[x] == -1) {
    printf("%d", x);
    return;
  }
  print(pre[x]);
  printf(" %d", x);
}
int main() {
  while (scanf("%d%I64d", &n, &d) != EOF) {
    top = 0;
    for (int i = 1; i <= n; i++) {
      scanf("%I64d", &a[i]);
      tmp[top++] = a[i];
      tmp[top++] = a[i] - d;
      tmp[top++] = a[i] + d;
    }
    sort(tmp, tmp + top);
    top = unique(tmp, tmp + top) - tmp;
    seg.Build(1, top, 1);
    memset(pre, -1, sizeof(pre));
    int ans = 0, en;
    for (int i = 1; i <= n; i++) {
      int low = ID(a[i] - d), up = ID(a[i] + d);
      Node ret = seg.Query(1, low, 1, top, 1);
      ret = max(ret, seg.Query(up, top, 1, top, 1));
      pre[i] = ret.id;
      int tlen = ret.len + 1;
      seg.Modify(ID(a[i]), i, tlen, 1, top, 1);
      if (tlen > ans) {
        ans = tlen;
        en = i;
      }
    }
    printf("%d\n", ans);
    print(en);
    printf("\n");
  }
  return 0;
}
