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 + 10, MAXseg = 4 * MAXn;
long long ar[MAXn], ar2[MAXn], n, d, ar3[MAXn], cnt = -1;
struct node {
  int l, r, ans, ind;
  node() { ind = l = r = ans = 0; }
  int size() { return r - l; }
  int unity(int lq, int rq) { return max(0, min(r, rq) - max(l, lq)); }
  int unity(int lq) { return unity(lq, lq + 1); }
  int init(int lq, int rq) { return unity(lq, rq) == size(); }
  bool leaf() { return size() == 1; }
};
node seg[MAXseg];
void build(int v, int l, int r) {
  seg[v].l = l;
  seg[v].r = r;
  if (seg[v].leaf()) return;
  int med = (l + r) / 2;
  build(2 * v, l, med);
  build(2 * v + 1, med, r);
}
pair<int, int> get(int v, int l, int r) {
  if (!seg[v].unity(l, r)) return pair<int, int>(0, 0);
  if (seg[v].init(l, r)) return pair<int, int>(seg[v].ans, seg[v].ind);
  pair<int, int> p1 = get(2 * v, l, r);
  pair<int, int> p2 = get(2 * v + 1, l, r);
  if (p1.first > p2.first) return p1;
  return p2;
}
void change(int v, int l, int x, int ind) {
  if (!seg[v].unity(l)) return;
  if (seg[v].leaf()) {
    if (seg[v].ans < x) {
      seg[v].ans = x;
      seg[v].ind = ind;
    }
    return;
  }
  change(2 * v, l, x, ind);
  change(2 * v + 1, l, x, ind);
  if (seg[2 * v].ans > seg[2 * v + 1].ans) {
    seg[v].ans = seg[2 * v].ans;
    seg[v].ind = seg[2 * v].ind;
  } else {
    seg[v].ans = seg[2 * v + 1].ans;
    seg[v].ind = seg[2 * v + 1].ind;
  }
}
int par[MAXn];
void getpar(int a) {
  if (a == -1) return;
  getpar(par[a]);
  cout << a + 1 << ' ';
}
int main() {
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    cin >> ar[i];
    ar2[i] = ar[i];
  }
  sort(ar2, ar2 + n);
  for (int i = 0; i < n; i++)
    if (cnt == -1 || ar2[i] != ar3[cnt]) ar3[++cnt] = ar2[i];
  cnt++;
  build(1, 0, cnt);
  for (int i = 0; i < n; i++) {
    pair<int, int> tmp(0, -1);
    int ind = upper_bound(ar3, ar3 + cnt, ar[i] - d) - ar3;
    if (ind != 0) {
      pair<int, int> hp = get(1, 0, ind);
      if (hp.first > tmp.first) tmp = hp;
    }
    ind = lower_bound(ar3, ar3 + cnt, ar[i] + d) - ar3;
    if (ind != n) {
      pair<int, int> hp = get(1, ind, cnt);
      if (hp.first > tmp.first) tmp = hp;
    }
    ind = lower_bound(ar3, ar3 + cnt, ar[i]) - ar3;
    par[i] = tmp.second;
    change(1, ind, tmp.first + 1, i);
  }
  pair<int, int> tmp = get(1, 0, cnt);
  cout << tmp.first << '\n';
  getpar(tmp.second);
}
