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>
struct debugger {
  template <typename T>
  debugger operator,(const T &v) {
    std::cout << v << " ";
    return (*this);
  }
} dbg;
using namespace std;
const int sz = 100000 + 10;
struct node {
  int m, idx;
  node() : m(0), idx(0){};
  node operator+(const node &a);
} tree[12 * sz + 10];
std::pair<int, int> arr[sz];
long long org[sz];
int ani[sz];
node node::operator+(const node &a) {
  node ret;
  if (this->m > a.m) {
    ret.m = this->m;
    ret.idx = this->idx;
  } else {
    ret.m = a.m;
    ret.idx = a.idx;
  }
  return ret;
}
node query(int n, int ql, int qr, int l, int r) {
  if (l > r || l > qr || ql > r) return node();
  if (l >= ql && r <= qr) return tree[n];
  int mid = l + r >> 1;
  return query(2 * n, ql, qr, l, mid) + query(2 * n + 1, ql, qr, mid + 1, r);
}
void update(int n, int ql, int qr, int l, int r, int val, int idx) {
  if (l > r || l > qr || ql > r) return;
  if (l == r) {
    if (val > tree[n].m) {
      tree[n].idx = idx;
    }
    tree[n].m = max(val, tree[n].m);
    return;
  }
  int mid = l + r >> 1;
  update(2 * n, ql, qr, l, mid, val, idx);
  update(2 * n + 1, ql, qr, mid + 1, r, val, idx);
  tree[n] = tree[2 * n] + tree[2 * n + 1];
}
int main() {
  std::ios_base::sync_with_stdio(false);
  int n;
  cin >> n;
  long long d;
  cin >> d;
  map<long long, int> m;
  for (int i = (1); i <= (n); ++i) {
    long long t;
    cin >> t;
    org[i] = t;
    m[t];
    m[t - d];
    m[t + d];
  }
  int cnt = 1;
  map<long long, int>::iterator it;
  for (it = m.begin(); it != m.end(); ++it) {
    it->second = cnt++;
  }
  for (int i = (1); i <= (n); ++i) {
    long long t = org[i];
    arr[i].first = m[t - d];
    arr[i].second = m[t + d];
    ;
  }
  int ans = 0, mxi = -1;
  for (int i = (1); i <= (n); ++i) {
    node q = query(1, 1, arr[i].first, 1, cnt) +
             query(1, arr[i].second, cnt, 1, cnt);
    int t = 1 + q.m;
    ;
    ani[i] = q.idx;
    if (t > ans) {
      mxi = i;
      ans = t;
    }
    int red = m[org[i]];
    update(1, red, red, 1, cnt, t, i);
  }
  cout << ans << "\n";
  ;
  if (ans != 0) {
    std::vector<int> idx;
    idx.push_back(mxi);
    while (ani[mxi] != 0) {
      idx.push_back(ani[mxi]);
      mxi = ani[mxi];
    }
    reverse((idx).begin(), (idx).end());
    for (int i = (0); i < (((int)((idx).size()))); ++i) {
      cout << idx[i] << " ";
    }
  }
}
