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;
using ll = long long;
const ll MOD = 1e9 + 7;
class DynamicSegmentTree {
 private:
  int index;
  ll maxValue;
  vector<pair<ll, int>> tree;
  vector<pair<int, int>> child;
  pair<ll, int> get(ll a, ll b, ll l, ll r, int v) {
    if (v == -1 || a > r || b < l) return {0ll, -1};
    if (a <= l && b >= r) return tree[v];
    ll m = (l + r) >> 1ll;
    return max(get(a, min(b, m), l, m, child[v].first),
               get(max(a, m + 1), b, m + 1, r, child[v].second));
  }
  void update(ll pos, ll l, ll r, int v, pair<ll, int> value) {
    if (l > r) return;
    if (l == r) {
      tree[v] = value;
      return;
    }
    ll m = (l + r) >> 1ll;
    if (pos <= m) {
      if (child[v].first == -1) {
        child[v].first = index++;
        tree.push_back({0, -1});
        child.push_back({-1, -1});
      }
      update(pos, l, m, child[v].first, value);
    } else {
      if (child[v].second == -1) {
        child[v].second = index++;
        tree.push_back({0, -1});
        child.push_back({-1, -1});
      }
      update(pos, m + 1, r, child[v].second, value);
    }
    tree[v] = max(
        (child[v].first == -1 ? make_pair(0ll, -1) : tree[child[v].first]),
        (child[v].second == -1 ? make_pair(0ll, -1) : tree[child[v].second]));
  }

 public:
  DynamicSegmentTree(ll maxVal) : index(1), maxValue(maxVal) {
    tree.push_back({0, -1});
    child.push_back({-1, -1});
  }
  pair<ll, int> get(ll a, ll b) { return get(a, b, 0, maxValue, 0); }
  void update(ll pos, pair<ll, int> value) {
    update(pos, 0, maxValue, 0, value);
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, d;
  cin >> n >> d;
  vector<ll> h(n);
  for (ll &i : h) cin >> i;
  DynamicSegmentTree dp(1e16);
  vector<int> p(n);
  int maxRes = 0, maxInd = 0;
  for (int i = 0; i < n; ++i) {
    pair<ll, int> r = max(dp.get(0, h[i] - d), dp.get(h[i] + d, 1e16 - 10));
    p[i] = r.second;
    if (r.first + 1 > maxRes) {
      maxRes = r.first + 1;
      maxInd = i;
    }
    dp.update(h[i], {r.first + 1, i});
  }
  cout << maxRes << '\n';
  vector<int> res;
  for (int i = maxInd; i != -1; i = p[i]) res.push_back(i + 1);
  reverse(res.begin(), res.end());
  for (int i : res) cout << i << ' ';
  return 0;
}
