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 + 5;
const int inf = 1e9;
const long long INF = 1e15 + 5;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 1000000007;
int n;
long long int a[N];
long long int d;
long long int dp[N];
int par[N];
struct node {
  node *l, *r;
  int mx, idx;
  node() : l(nullptr), r(nullptr), mx(0), idx(0) {}
  node(node *l, node *r, int mx, int idx) : l(l), r(r), mx(mx), idx(idx) {}
  void combine(long long int b, long long int e) {
    long long int m = (b + e) >> 1;
    if (l && r) {
      mx = max(mx, max(l->mx, r->mx));
      if (l->mx >= mx) idx = l->idx;
      if (r->mx >= mx) idx = r->idx;
    } else if (l && !r) {
      mx = max(mx, l->mx);
      if (l->mx >= mx) idx = l->idx;
    } else if (!l && r) {
      mx = max(mx, r->mx);
      if (r->mx >= mx) idx = r->idx;
    }
  }
} * root;
typedef node *pnode;
void update(pnode &cur, long long int b, long long int e, long long int pos,
            int val, int id) {
  if (!cur) cur = new node();
  if (pos > e || pos < b || b > e) return;
  if (b == e && b == pos) {
    cur->mx = val;
    cur->idx = id;
    return;
  }
  long long int m = (b + e) >> 1;
  if (pos <= m)
    update(cur->l, b, m, pos, val, id);
  else
    update(cur->r, m + 1, e, pos, val, id);
  cur->combine(b, e);
}
pair<int, int> query(pnode &cur, long long int b, long long int e,
                     long long int i, long long int j) {
  if (!cur) return {0, 0};
  if (i > e || j < b || b > e) return {0, 0};
  if (i <= b && j >= e) return {cur->mx, cur->idx};
  long long int m = (b + e) >> 1;
  pair<int, int> x = query(cur->l, b, m, i, j);
  pair<int, int> y = query(cur->r, m + 1, e, i, j);
  pair<int, int> ret = {0, 0};
  if (x.first >= y.first)
    ret.first = max(ret.first, x.first), ret.second = x.second;
  else
    ret.first = max(ret.first, y.first), ret.second = y.second;
  return ret;
}
int main(int argc, char const *argv[]) {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cin >> n >> d;
  for (int i = 1; i <= n; i++) cin >> a[i];
  root = NULL;
  for (int i = 1; i <= n; i++) {
    pair<int, int> x = query(root, 1, INF, 1, a[i] - d);
    pair<int, int> y = query(root, 1, INF, a[i] + d, INF);
    pair<int, int> m = max(x, y);
    dp[i] = m.first + 1;
    par[i] = m.second;
    update(root, 1, INF, a[i], dp[i], i);
  }
  int mx = 0;
  for (int i = 1; i <= n; i++)
    if (dp[i] > dp[mx]) mx = i;
  cout << dp[mx] << "\n";
  vector<int> path;
  while (mx > 0) path.push_back(mx), mx = par[mx];
  for (int i = path.size() - 1; i >= 0; i--) cout << path[i] << " ";
  return 0;
}
