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 N = 1e5 + 7;
namespace SegmentTree {
pair<int, int> t[4 * N];
void pull(int v) { t[v] = max(t[2 * v + 1], t[2 * v + 2]); }
void init() { fill(t, t + 4 * N, make_pair(-1, -1)); }
void set(int v, int l, int r, int pos, pair<int, int> val) {
  if (l + 1 == r) {
    t[v] = val;
  } else {
    int m = (r + l) >> 1;
    if (pos < m) {
      set(2 * v + 1, l, m, pos, val);
    } else {
      set(2 * v + 2, m, r, pos, val);
    }
    pull(v);
  }
}
void query(int v, int l, int r, int ql, int qr, pair<int, int> &ans) {
  if (r <= ql || qr <= l) {
    return;
  } else if (ql <= l && r <= qr) {
    ans = max(ans, t[v]);
  } else {
    int m = (r + l) >> 1;
    query(2 * v + 1, l, m, ql, qr, ans);
    query(2 * v + 2, m, r, ql, qr, ans);
  }
}
void set(int pos, pair<int, int> val) { set(0, 0, N, pos, val); }
pair<int, int> query(int l, int r) {
  pair<int, int> ans = {-1, -1};
  query(0, 0, N, l, r, ans);
  return ans;
}
}  // namespace SegmentTree
int n;
long long a[N];
int dp[N];
int wr[N];
vector<long long> seen;
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  SegmentTree::init();
  long long d;
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    seen.push_back(a[i]);
  }
  sort(seen.begin(), seen.end());
  seen.resize(unique(seen.begin(), seen.end()) - seen.begin());
  for (int i = 0; i < n; i++) {
    a[i] = lower_bound(seen.begin(), seen.end(), a[i]) - seen.begin();
  }
  for (int i = n - 1; i >= 0; i--) {
    pair<int, int> ans = {-1, -1};
    int l =
        upper_bound(seen.begin(), seen.end(), seen[a[i]] - d) - seen.begin();
    int r =
        lower_bound(seen.begin(), seen.end(), seen[a[i]] + d) - seen.begin();
    ans = max(ans, SegmentTree::query(0, l));
    ans = max(ans, SegmentTree::query(r, n));
    if (ans.first == -1) ans.first = 0;
    dp[i] = ans.first + 1;
    wr[i] = ans.second;
    SegmentTree::set(a[i], {dp[i], i});
  }
  int pos = max_element(dp, dp + n) - dp;
  cout << dp[pos] << '\n';
  while (pos != -1) {
    cout << pos + 1 << ' ';
    pos = wr[pos];
  }
  cout << '\n';
}
