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 INF = 1e9;
const int MAX_COUNT = 1e5 + 1;
const int MOD = 1e9 + 7;
template <typename T>
void print_array(T first, T last, const string& label = "") {
  if (label.size()) {
    cout << label << ": ";
  }
  while (first != last) {
    cout << *first++ << " ";
  }
  cout << endl;
}
class Indent {
 public:
  friend ostream& operator<<(ostream& o, const Indent& indent);
  Indent() { ++level; }
  ~Indent() { --level; }

 private:
  static int level;
};
int Indent::level = -1;
ostream& operator<<(ostream& o, const Indent& indent) {
  return o << string(indent.level * 4, ' ');
}
ostream& operator<<(ostream& o, const tuple<int, int>& t) {
  return o << "(" << get<0>(t) << ", " << get<1>(t) << ")";
}
int n;
int d;
long long data[MAX_COUNT];
long long c[MAX_COUNT];
int bt[MAX_COUNT];
tuple<int, int> st[4 * MAX_COUNT + 1];
void st_update(int pos, tuple<int, int> val, int tl, int tr, int i) {
  if (tr == tl) {
    st[i] = val;
    return;
  }
  int tm = tl + (tr - tl) / 2;
  int li = 2 * i + 1;
  int ri = 2 * i + 2;
  if (pos <= tm) {
    st_update(pos, val, tl, tm, li);
  } else {
    st_update(pos, val, tm + 1, tr, ri);
  }
  st[i] = max(st[li], st[ri]);
}
tuple<int, int> st_query_max(int ql, int qr, int tl, int tr, int i) {
  if (ql > tr || qr < tl) return make_tuple(-1, 0);
  if (ql <= tl && qr >= tr) {
    return st[i];
  }
  int tm = tl + (tr - tl) / 2;
  int li = 2 * i + 1;
  int ri = 2 * i + 2;
  tuple<int, int> res_l = st_query_max(ql, qr, tl, tm, li);
  tuple<int, int> res_r = st_query_max(ql, qr, tm + 1, tr, ri);
  tuple<int, int> res = max(res_l, res_r);
  return res;
}
int main() {
  ios::sync_with_stdio(false);
  cin >> n >> d;
  for (int i = 0; i < (n); ++i) {
    cin >> data[i];
    c[i] = data[i];
  }
  sort(c, c + n);
  int c_size = distance(c, unique(c, c + n));
  int max_value = c_size;
  fill(begin(st), end(st), tuple<int, int>{0, -1});
  int max_len = 0;
  int max_len_ind = -1;
  for (int i = 0; i < (n); ++i) {
    int l = distance(c, lower_bound(c, c + c_size, data[i] - d));
    if (c[l] > data[i] - d) {
      --l;
    }
    int r = distance(c, lower_bound(c, c + c_size, data[i] + d));
    tuple<int, int> max_ind_l = st_query_max(0, l, 0, max_value, 0);
    tuple<int, int> max_ind_r = st_query_max(r, max_value, 0, max_value, 0);
    tuple<int, int> max_ind = max(max_ind_l, max_ind_r);
    int len = max(get<0>(max_ind) + 1, 1);
    int ii = distance(c, lower_bound(c, c + c_size, data[i]));
    st_update(ii, make_tuple(len, i), 0, max_value, 0);
    if (len > max_len) {
      max_len = len;
      max_len_ind = i;
    }
    bt[i] = get<1>(max_ind);
  }
  vector<int> path;
  while (max_len_ind != -1) {
    path.push_back(max_len_ind);
    max_len_ind = bt[max_len_ind];
  }
  cout << max_len << endl;
  for (auto it = path.rbegin(); it != path.rend(); ++it) {
    cout << *it + 1 << " ";
  }
  cout << endl;
  return 0;
}
