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 N = 1e5 + 10;
struct segment {
  int l, r, mx_id;
  int size() { return r - l; }
  int unity(int _l, int _r) { return max(0, min(r, _r) - max(l, _l)); }
  segment(int _l = 0, int _r = 0) {
    l = _l;
    r = _r;
    mx_id = -1;
  }
} seg[N << 2];
int n, _dp[N], par[N];
long long h[N], d;
int *dp = &_dp[3];
void build(int, int, int = 1);
segment getMax(int, int, int = 1);
void change(int, int, int = 1);
segment merge(segment, segment);
int main() {
  cin >> n >> d;
  vector<long long> hs;
  for (int i = 0; i < n; i++) {
    cin >> h[i];
    hs.push_back(h[i]);
  }
  hs.push_back(0);
  hs.push_back(2e15);
  sort(hs.begin(), hs.end());
  hs.resize(unique(hs.begin(), hs.end()) - hs.begin());
  build(0, hs.size());
  int ans = 0;
  for (int i = 0; i < n; i++) {
    int head =
        upper_bound(hs.begin(), hs.end(), max(h[i] - d, 0LL)) - hs.begin();
    int tail =
        lower_bound(hs.begin(), hs.end(), min(h[i] + d, (long long)2e15)) -
        hs.begin();
    par[i] = merge(getMax(0, head), getMax(tail, hs.size())).mx_id;
    dp[i] = dp[par[i]] + 1;
    int ind = lower_bound(hs.begin(), hs.end(), h[i]) - hs.begin();
    change(ind, i);
    if (dp[i] > dp[ans]) ans = i;
  }
  cout << dp[ans] << endl;
  vector<int> seq;
  while (ans != -1) {
    seq.push_back(ans);
    ans = par[ans];
  }
  reverse(seq.begin(), seq.end());
  for (int i : seq) cout << i + 1 << ' ';
  cout << endl;
}
void build(int l, int r, int v) {
  seg[v] = segment(l, r);
  if (r - l == 1) return;
  int med = (l + r) / 2;
  build(l, med, v << 1);
  build(med, r, v << 1 | 1);
}
segment getMax(int l, int r, int v) {
  if (seg[v].unity(l, r) == 0) return segment();
  if (seg[v].unity(l, r) == seg[v].size()) return seg[v];
  return merge(getMax(l, r, v << 1), getMax(l, r, v << 1 | 1));
}
void change(int ind, int val_id, int v) {
  if (seg[v].unity(ind, ind + 1) == 0) return;
  if (seg[v].size() == 1) {
    if (dp[seg[v].mx_id] < dp[val_id]) seg[v].mx_id = val_id;
    return;
  }
  change(ind, val_id, v << 1);
  change(ind, val_id, v << 1 | 1);
  seg[v] = merge(seg[v << 1], seg[v << 1 | 1]);
}
segment merge(segment a, segment b) {
  segment res(min(a.l, b.l), max(a.r, b.r));
  if (dp[a.mx_id] > dp[b.mx_id])
    res.mx_id = a.mx_id;
  else
    res.mx_id = b.mx_id;
  return res;
}
