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 string gNoSolutionOutput = "-1";
void noSolution() {
  cout << gNoSolutionOutput;
  exit(0);
}
struct ct {
  int l, r;
  int n;
  long long x;
  int val;
  int id;
  pair<int, int> mn;
  ct(long long x = 0, int val = 0, int id = -1)
      : l(0), r(0), n(1), x(x), val(val), id(id), mn(make_pair(val, id)) {}
};
const int MAXN = 200001;
int buffer_size = 1;
ct buffer[MAXN];
int create(ct a) {
  buffer[buffer_size++] = a;
  return buffer_size - 1;
}
int size(int a) { return a == 0 ? 0 : buffer[a].n; }
pair<int, int> getMin(int a) {
  return a == 0 ? make_pair(0, -1) : buffer[a].mn;
}
int getId(int a) { return a == 0 ? -1 : buffer[a].id; }
void recalc_down(int a) {}
void recalc_up(int a) {
  buffer[a].mn = max(make_pair(buffer[a].val, buffer[a].id),
                     max(getMin(buffer[a].l), getMin(buffer[a].r)));
  buffer[a].n = size(buffer[a].l) + size(buffer[a].r) + 1;
}
int merge(int a, int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  recalc_down(a);
  recalc_down(b);
  if ((rand() * (RAND_MAX + 1) + rand()) % (buffer[b].n + buffer[a].n) <
      buffer[b].n) {
    buffer[b].l = merge(a, buffer[b].l);
    recalc_up(b);
    return b;
  } else {
    buffer[a].r = merge(buffer[a].r, b);
    recalc_up(a);
    return a;
  }
}
template <int MIDDLE_L = 0>
pair<int, int> split(int a, long long x) {
  if (a == 0) return pair<int, int>(0, 0);
  recalc_down(a);
  if (!MIDDLE_L && buffer[a].x < x || MIDDLE_L && !(x < buffer[a].x)) {
    pair<int, int> p = split<MIDDLE_L>(buffer[a].r, x);
    buffer[a].r = p.first;
    recalc_up(a);
    return pair<int, int>(a, p.second);
  } else {
    pair<int, int> p = split<MIDDLE_L>(buffer[a].l, x);
    buffer[a].l = p.second;
    recalc_up(a);
    return pair<int, int>(p.first, a);
  }
}
void debug(int a, int depth = 0) {
  for (int i = 0; i < depth; ++i) std::cout << "  ";
  if (a == 0) {
    std::cout << "NULL\n";
    return;
  }
  std::cout << "val: " << buffer[a].x << " max: " << buffer[a].mn.first << "\n";
  debug(buffer[a].r, depth + 1);
  debug(buffer[a].l, depth + 1);
}
int main() {
  int n, d;
  cin >> n >> d;
  vector<int> A(n);
  vector<int> P(n);
  int tree = 0;
  for (int i = 0; i < n; ++i) {
    long long h;
    cin >> h;
    pair<int, int> p1 = split<1>(tree, h - d);
    pair<int, int> p2 = split<0>(p1.second, h + d);
    pair<int, int> mnp = max(getMin(p1.first), getMin(p2.second));
    int mn = mnp.first;
    int id = mnp.second;
    tree = merge(p1.first, merge(p2.first, p2.second));
    p1 = split<0>(tree, h);
    p2 = split<1>(p1.second, h);
    A[i] = mn + 1;
    P[i] = id;
    if (p2.first == 0 || getMin(p2.first).first < A[i]) {
      p2.first = create(ct(h, A[i], i));
    }
    tree = merge(p1.first, merge(p2.first, p2.second));
  }
  int id = 0;
  for (int i = 1; i < n; ++i) {
    if (A[id] < A[i]) id = i;
  }
  vector<int> ans;
  while (id != -1) {
    ans.push_back(id);
    id = P[id];
  }
  cout << ans.size() << "\n";
  for (int i = ans.size() - 1; i >= 0; --i) cout << ans[i] + 1 << " ";
  return 0;
}
