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 long long INF = 1LL << 60;
template <typename Monoid>
struct SegmentTree {
  using F = function<Monoid(Monoid, Monoid)>;
  const F f;
  const Monoid M1;
  int sz;
  vector<Monoid> dat;
  SegmentTree(int n, const F f, const Monoid& M1) : f(f), M1(M1), sz(1) {
    while (sz < n) sz <<= 1;
    dat.assign(sz * 2, M1);
  }
  void set(int k, const Monoid& x) { dat[k + sz] = x; }
  void build() {
    for (int k = sz - 1; k > 0; k--) {
      dat[k] = f(dat[2 * k], dat[2 * k + 1]);
    }
  }
  void update(int k, const Monoid& x) {
    dat[k += sz] = x;
    while (k >>= 1) dat[k] = f(dat[2 * k], dat[2 * k + 1]);
  }
  Monoid get(int a, int b) {
    Monoid L = M1, R = M1;
    for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
      if (a & 1) L = f(L, dat[a++]);
      if (b & 1) R = f(dat[--b], R);
    }
    return f(L, R);
  }
  Monoid operator[](const int& k) const { return dat[k + sz]; }
  friend ostream& operator<<(ostream& os, SegmentTree<Monoid>& seg) {
    for (int i = 0; i < seg.sz; i++) os << seg[i] << " ";
    return os;
  }
};
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (auto& vi : vec) os << vi << " ";
  return os;
}
int main() {
  int n, d;
  cin >> n >> d;
  vector<pair<long long, int>> ps(n);
  for (int i = 0; i < n; i++) cin >> ps[i].first, ps[i].second = i;
  sort(begin(ps), end(ps));
  vector<int> ord(n);
  for (int i = 0; i < n; i++) ord[ps[i].second] = i;
  using P = pair<int, int>;
  SegmentTree<P> seg(n, [](P a, P b) { return max(a, b); }, {-INF, -1});
  for (int i = 0; i < n; i++) seg.set(ord[i], {-1, i});
  seg.build();
  vector<int> prv(n, -1);
  seg.update(ord[0], {0, 0});
  for (int i = 1; i < n; i++) {
    long long cur_h = ps[ord[i]].first;
    int from =
        upper_bound(begin(ps), end(ps), make_pair(cur_h - d, n)) - begin(ps);
    int to =
        upper_bound(begin(ps), end(ps), make_pair(cur_h + d, -1)) - begin(ps);
    auto val = max(seg.get(0, from), seg.get(to, n));
    seg.update(ord[i], {val.first + 1, i});
    prv[i] = val.second;
  }
  vector<int> res;
  int p = seg.get(0, n).second;
  while (~p) res.emplace_back(p + 1), p = prv[p];
  reverse(begin(res), end(res));
  cout << res.size() << endl;
  cout << res << endl;
  return 0;
}
