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 MAXN = (int)1e5 + 10;
const long long linf = (long long)1e18 + 10;
class segments_tree {
 private:
  int l, r;
  pair<int, int> mx;
  segments_tree *left, *right;

 public:
  segments_tree(int l, int r) : l(l), r(r) {
    mx = make_pair(0, -1);
    left = right = NULL;
    if (l < r) {
      left = new segments_tree(l, (l + r) / 2);
      right = new segments_tree((l + r) / 2 + 1, r);
    }
  }
  void modify(int _l, int _r, int d, int idx) {
    if (l == _l && r == _r)
      mx = max(mx, make_pair(d, idx));
    else {
      if (_l <= left->r) left->modify(_l, min(left->r, _r), d, idx);
      if (_r >= right->l) right->modify(max(right->l, _l), _r, d, idx);
      mx = max(left->mx, right->mx);
    }
  }
  pair<int, int> get_mx(int _l, int _r) {
    if (_l > _r) return make_pair(-1, -1);
    if (_l == l && _r == r) return mx;
    pair<int, int> res = make_pair(0, -1);
    if (_l <= left->r) res = max(res, left->get_mx(_l, min(left->r, _r)));
    if (_r >= right->l) res = max(res, right->get_mx(max(right->l, _l), _r));
    return res;
  }
};
int n;
long long h[MAXN], d;
segments_tree *t;
void read_input() {
  cin >> n >> d;
  for (int i = 0; i < n; ++i) cin >> h[i];
}
vector<long long> num;
map<long long, long long> knum;
int sz;
void compression() {
  for (int i = 0; i < n; ++i) num.push_back(h[i]);
  sort(num.begin(), num.end());
  num.resize(unique(num.begin(), num.end()) - num.begin());
  for (int i = 0; i < num.size(); ++i) knum[num[i]] = i;
  for (int i = 0; i < n; ++i) h[i] = knum[h[i]];
  sz = num.size();
}
int f[MAXN];
int p[MAXN];
void solve() {
  t = new segments_tree(0, sz + 10);
  for (int i = 0; i < n; ++i) {
    int lpos = upper_bound(num.begin(), num.end(), num[h[i]] - d) - num.begin();
    if (lpos < 0) lpos++;
    if (num[lpos] > num[h[i]] - d) lpos--;
    int rpos = lower_bound(num.begin(), num.end(), num[h[i]] + d) - num.begin();
    if (rpos >= num.size()) rpos--;
    if (num[rpos] < num[h[i]] + d) rpos++;
    pair<int, int> mx = t->get_mx(0, lpos);
    mx = max(mx, t->get_mx(rpos, sz + 10));
    f[i] = mx.first + 1;
    p[i] = mx.second;
    t->modify(h[i], h[i], f[i], i);
  }
}
void write_output() {
  int mx_idx = -1;
  for (int i = 0; i < n; ++i)
    if (mx_idx == -1 || (f[mx_idx] < f[i])) mx_idx = i;
  cout << f[mx_idx] << endl;
  vector<int> ans;
  int cur = mx_idx;
  while (cur != -1) {
    ans.push_back(cur + 1);
    cur = p[cur];
  }
  reverse(ans.begin(), ans.end());
  for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
  cout << endl;
}
int main() {
  read_input();
  compression();
  solve();
  write_output();
  return 0;
}
