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 long long INF = 1e9 + 7;
const long long N = 1e5 + 5;
const long double EPS = 1e-12;
const long long P = 239017;
const long long MOD = 998244353;
map<long long, long long> mp;
struct segtree {
  long long s;
  vector<pair<long long, long long> > tree;
  void init(long long n) {
    s = 1;
    while (s < n) s *= 2;
    tree.resize(2 * s + 1);
  }
  void upd(long long i, long long v, long long ind, long long first,
           long long lx, long long rx) {
    if (lx + 1 == rx) {
      tree[first] = {v, ind};
      return;
    }
    long long m = (lx + rx) / 2;
    if (i < m)
      upd(i, v, ind, 2 * first + 1, lx, m);
    else
      upd(i, v, ind, 2 * first + 2, m, rx);
    tree[first] = max(tree[2 * first + 1], tree[2 * first + 2]);
  }
  pair<long long, long long> get_max(long long l, long long r, long long first,
                                     long long lx, long long rx) {
    if (lx >= r || rx <= l) return {0, 0};
    if (lx >= l && rx <= r) return tree[first];
    long long m = (lx + rx) / 2;
    return max(get_max(l, r, 2 * first + 1, lx, m),
               get_max(l, r, 2 * first + 2, m, rx));
  }
};
void solve() {
  long long n, d;
  cin >> n >> d;
  vector<long long> a(n);
  for (auto &i : a) cin >> i;
  segtree sg;
  sg.init(n);
  vector<long long> b = a;
  sort(b.begin(), b.end());
  for (long long i = 0; i < n; i++) {
    mp[b[i]] = i;
  }
  vector<long long> p(n, -1);
  for (long long i = 0; i < n; i++) {
    pair<long long, long long> l = sg.get_max(
        0, upper_bound(b.begin(), b.end(), a[i] - d) - b.begin(), 0, 0, sg.s);
    pair<long long, long long> r = sg.get_max(
        lower_bound(b.begin(), b.end(), a[i] + d) - b.begin(), n, 0, 0, sg.s);
    if (l.first > r.first && l.first)
      p[i] = l.second;
    else if (r.first)
      p[i] = r.second;
    sg.upd(mp[a[i]], max(l.first, r.first) + 1, i, 0, 0, sg.s);
  }
  cout << sg.tree[0].first << '\n';
  long long i = sg.tree[0].second;
  vector<long long> ans;
  while (1) {
    ans.push_back(i + 1);
    if (p[i] == -1) break;
    i = p[i];
  }
  reverse(ans.begin(), ans.end());
  for (auto i : ans) cout << i << ' ';
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  long long t = 1;
  while (t--) {
    solve();
  }
  return 0;
}
