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 = 1000000000;
const long long INF_LL = 1000000000000000000LL;
const double pi = 2 * acos(0.0);
template <class T>
void smin(T& a, T b) {
  if (a > b) a = b;
}
template <class T>
void smax(T& a, T b) {
  if (a < b) a = b;
}
template <class T>
T gcd(T a, T b) {
  return b == 0 ? a : gcd(b, a % b);
}
template <class T>
T sqr(T a) {
  return a * a;
}
template <typename Iterator>
void print(const char* fmt, Iterator begin, Iterator end,
           const char* separator = " ") {
  for (Iterator it = begin; it != end; ++it) {
    if (it != begin) printf(separator);
    printf(fmt, *it);
  }
  printf("\n");
}
template <int N, class T, typename Op>
struct TreeOp {
  Op op;
  int n;
  T t[2 * N];
  TreeOp(int n = 0) : op(), n(n) {}
  TreeOp(const Op& op, int n = 0) : op(op), n(n) {}
  T& operator[](int p) { return t[n + p]; }
  void build() {
    for (int i(n - 1), _b(1); i >= _b; --i) t[i] = op(t[i << 1], t[i << 1 | 1]);
  }
  void upd(int p, T newv) {
    for (t[p += n] = newv; p > 1; p >>= 1) t[p >> 1] = op(t[p], t[p ^ 1]);
  }
  T get(int l, int r) {
    T res = t[l += n];
    for (r += n; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
      if (l & 1) res = op(res, t[l]);
      if (~r & 1) res = op(res, t[r]);
    }
    return res;
  }
};
const int h = 100011;
int n, d;
long long a[h];
pair<long long, int> o[h];
int u[h], p[h];
template <class T>
struct max_s {
  T operator()(T a, T b) { return max(a, b); }
};
TreeOp<h, pair<int, int>, max_s<pair<int, int> > > tree;
int main() {
  scanf("%d%d", &n, &d);
  for (int i(0), _b(n); i < _b; ++i) {
    scanf("%I64d", a + i);
    o[i] = pair<long long, int>(a[i], i);
  }
  sort(o, o + n);
  for (int i(0), _b(n); i < _b; ++i) u[o[i].second] = i;
  tree.n = n;
  for (int i(0), _b(n); i < _b; ++i) {
    int r = upper_bound(o, o + n, pair<long long, int>(a[i] - d, INF)) - o - 1;
    int l = lower_bound(o, o + n, pair<long long, int>(a[i] + d, -INF)) - o;
    pair<int, int> res(0, 0);
    if (r >= 0) smax(res, tree.get(0, r));
    if (l < n) smax(res, tree.get(l, n - 1));
    p[i] = res.second;
    tree.upd(u[i], pair<int, int>(res.first + 1, i));
  }
  pair<int, int> ans = tree.get(0, n - 1);
  printf("%d\n", ans.first);
  int v = ans.second;
  vector<int> s;
  for (int i(0), _b(ans.first); i < _b; ++i) {
    s.push_back(v + 1);
    v = p[v];
  }
  reverse((s).begin(), (s).end());
  print("%d", (s).begin(), (s).end());
  return 0;
}
