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>
struct file_closer {
  FILE *in, *out;
  file_closer() {
    in = freopen("input.txt", "r", stdin);
    out = freopen("output.txt", "w", stdout);
  }
  ~file_closer() {
    fclose(in);
    fclose(out);
  }
};
using namespace std;
struct Treap {
  Treap *left, *right;
  pair<int, pair<long long, int> > tval;
  long long key;
  int prior, cnt, ind;
  Treap() {
    key = cnt = -1;
    tval = make_pair(cnt, make_pair(key, -1));
    prior = rand();
    left = right = NULL;
  }
  Treap(long long x, int y, int _ind = 0) {
    key = x;
    cnt = y;
    prior = rand();
    left = right = NULL;
    ind = _ind;
    tval = make_pair(y, make_pair(x, ind));
  }
};
typedef Treap *pTreap;
pair<int, pair<long long, int> > getValue(pTreap root) {
  if (!root) return make_pair(-1, make_pair(-1, -1));
  return root->tval;
}
void update(pTreap root) {
  if (!root) return;
  pair<int, pair<long long, int> > tv1, tv2, tv3;
  tv1 = getValue(root->left);
  tv2 = getValue(root->right);
  tv3 = make_pair(root->cnt, make_pair(root->key, root->ind));
  root->tval = max(tv1, max(tv2, tv3));
}
void split(pTreap root, pTreap &L, pTreap &R, long long key) {
  if (!root) {
    L = R = NULL;
    return;
  }
  if (root->key <= key) {
    split(root->right, root->right, R, key);
    L = root;
  } else {
    split(root->left, L, root->left, key);
    R = root;
  }
  update(L);
  update(R);
}
void merge(pTreap &root, pTreap L, pTreap R) {
  if (!L || !R) {
    root = (!L ? R : L);
    return;
  }
  if (L->prior > R->prior) {
    merge(L->right, L->right, R);
    root = L;
  } else {
    merge(R->left, L, R->left);
    root = R;
  }
  update(root);
}
pair<int, int> Add(pTreap &root, long long x, long long d, int _ind) {
  pTreap L, R, T;
  split(root, L, R, x - d);
  split(R, T, R, x + d - 1);
  auto tp1 = getValue(L), tp2 = getValue(R);
  tp1 = max(tp1, tp2);
  int cnt = (tp1.first == -1 ? 0 : tp1.first) + 1;
  int index = (tp1.first == -1 ? _ind : tp1.second.second);
  merge(L, L, T);
  merge(root, L, R);
  split(root, L, R, x - 1);
  split(R, T, R, 1);
  if (T == NULL) {
    T = new Treap(x, cnt, _ind);
  } else {
    if (T->cnt < cnt) {
      T->cnt = cnt;
      T->ind = _ind;
      update(T);
    }
  }
  merge(L, L, T);
  merge(root, L, R);
  return make_pair(cnt, index);
}
vector<int> prv;
vector<long long> v;
vector<int> tans;
int main() {
  int n;
  long long d, f;
  cin >> n >> d;
  pTreap root = NULL;
  pair<int, int> pr;
  pair<int, int> ans = make_pair(-1, -1);
  for (int i = 0; i < (int)n; i++) {
    cin >> f;
    pr = Add(root, f, d, i);
    ans = max(ans, make_pair(pr.first, i));
    v.push_back(f);
    prv.push_back(pr.second);
  }
  int tprv = ans.second;
  do {
    tans.push_back(tprv);
    if (prv[tprv] == tprv) break;
    tprv = prv[tprv];
  } while (true);
  cout << tans.size() << '\n';
  for (int i = (int)tans.size() - 1; i >= 0; i--) cout << tans[i] + 1 << ' ';
  return 0;
}
