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;
int GCD(int a, int b) {
  if (!a) return b;
  return GCD(b % a, a);
}
long long A(long long a) { return a > 0 ? a : -a; }
vector<long long> h;
map<long long, int> compx;
vector<int> ans, par;
struct node {
  int mx = 0;
  int idx = -1;
  void merge(const node &l, const node &r) {
    if (l.mx < r.mx) {
      mx = r.mx;
      idx = r.idx;
    } else {
      mx = l.mx;
      idx = l.idx;
    }
  }
};
node tree[(100100 * 3) * 4 + 1];
void update(int root, int st, int en, int pos, int val) {
  if (st == en) {
    assert(st == pos);
    tree[root].mx = val;
    tree[root].idx = pos;
    return;
  }
  int mid = (st + en) / 2;
  if (pos <= mid) {
    update(root * 2, st, mid, pos, val);
  } else {
    update(root * 2 + 1, mid + 1, en, pos, val);
  }
  tree[root].merge(tree[root * 2], tree[root * 2 + 1]);
}
node FAIL;
node query(int root, int st, int en, int l, int r) {
  if (st > r || en < l) return FAIL;
  if (l <= st && en <= r) {
    return tree[root];
  }
  int mid = (st + en) / 2;
  node left = query(root * 2, st, mid, l, r);
  node right = query(root * 2 + 1, mid + 1, en, l, r);
  node ret;
  ret.merge(left, right);
  return ret;
}
int main() {
  clock_t startTime = clock();
  ios_base::sync_with_stdio(false);
  int n, d;
  cin >> n >> d;
  h.reserve(n);
  ans.resize(n);
  par.resize(n);
  for (int i = (0); i < (int)(n); i++) {
    long long z;
    cin >> z;
    h.push_back(z);
    compx[z] = 0;
    compx[z - d] = 0;
    compx[z + d] = 0;
  }
  int cnt = 0;
  for (__typeof(compx.begin()) it = compx.begin(); it != compx.end(); it++) {
    it->second = cnt++;
  }
  ans[0] = 1;
  par[0] = 0;
  update(1, 0, cnt - 1, compx[h[0]], 1);
  for (int i = (1); i < (int)(n); i++) {
    long long curval = h[i];
    int mapval = compx[curval];
    int left = 0;
    int right = compx[curval - d];
    node mn = query(1, 0, cnt - 1, left, right);
    int cur = 1, p = i;
    if (mn.idx != -1) {
      if (cur < mn.mx + 1) {
        cur = mn.mx + 1;
        p = mn.idx;
      }
    }
    left = compx[curval + d];
    right = cnt - 1;
    mn = query(1, 0, cnt - 1, left, right);
    if (mn.idx != -1) {
      if (cur < mn.mx + 1) {
        cur = mn.mx + 1;
        p = mn.idx;
      }
    }
    ans[i] = cur;
    par[i] = p;
    update(1, 0, cnt - 1, compx[h[i]], cur);
  }
  int imx = max_element(ans.begin(), ans.end()) - ans.begin();
  int mx = ans[imx];
  cout << mx << "\n";
  stack<int> out;
  long long last = (1LL << 62);
  for (int i = n - 1; i >= 0; i--) {
    if (ans[i] == mx && abs(h[i] - last) >= d) {
      last = h[i];
      mx -= 1;
      out.push(i + 1);
    }
  }
  while (!out.empty()) {
    cout << out.top() << " ";
    out.pop();
  }
  clock_t endTime = clock();
  cerr << "\nTime:" << double(endTime - startTime) / CLOCKS_PER_SEC
       << " seconds\n";
  return 0;
}
