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 = 3 * 100000;
pair<long long, long long> tree[4 * N];
map<long long, long long> compress;
map<long long, long long> decompress;
pair<long long, long long> combine(pair<long long, long long> a,
                                   pair<long long, long long> b) {
  if (a.first > b.first)
    return a;
  else
    return b;
}
void update(long long node, long long l, long long r, long long x,
            long long idx, long long val) {
  if (l > r || l > x || r < x) return;
  if (l == r) {
    if (tree[node].first > val) return;
    tree[node].first = val;
    tree[node].second = idx;
    return;
  }
  long long mid = (l + r) / 2;
  update(2 * node, l, mid, x, idx, val);
  update(2 * node + 1, mid + 1, r, x, idx, val);
  tree[node] = combine(tree[2 * node], tree[2 * node + 1]);
}
pair<long long, long long> query(long long node, long long l, long long r,
                                 long long a, long long b) {
  if (l > b || r < a || l > r || a > b) return {-1, -1};
  if (a <= l && r <= b) return tree[node];
  long long mid = (l + r) / 2;
  return combine(query(2 * node, l, mid, a, b),
                 query(2 * node + 1, mid + 1, r, a, b));
}
long long INF = 1e16;
int main(void) {
  for (int i = 0; i < 4 * N; i++) tree[i].first = tree[i].second = -1;
  long long n, d;
  cin >> n >> d;
  set<long long> unique;
  long long arr[n + 1];
  for (int i = 1; i <= n; i++) {
    cin >> arr[i];
    unique.insert(arr[i]);
    unique.insert(arr[i] - d);
    unique.insert(arr[i] + d);
  }
  long long cnt = 0;
  for (auto it : unique) {
    compress[INF + it] = ++cnt;
    decompress[cnt] = it;
  }
  pair<long long, long long> dp[n + 1];
  dp[n].first = 1;
  dp[n].second = n;
  update(1, 1, cnt, compress[INF + arr[n]], n, 1);
  long long ans = 1;
  long long idx = n;
  for (long long i = n - 1; i > 0; i--) {
    long long l = arr[i] - d;
    long long r = arr[i] + d;
    pair<long long, long long> temp =
        combine(query(1, 1, cnt, 1, compress[l + INF]),
                query(1, 1, cnt, compress[r + INF], cnt));
    if (temp.first == -1) {
      dp[i].first = 1;
      dp[i].second = i;
    } else {
      dp[i].first = 1 + temp.first;
      dp[i].second = temp.second;
    }
    update(1, 1, cnt, compress[arr[i] + INF], i, dp[i].first);
    if (ans < dp[i].first) {
      ans = dp[i].first;
      idx = i;
    }
  }
  cout << ans << endl;
  while (dp[idx].second != idx) {
    cout << idx << " ";
    idx = dp[idx].second;
  }
  cout << idx << endl;
  return 0;
}
