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;
struct SegmentTree {
  struct Node {
    long long l, r, val, which;
    Node() {}
    Node(long long l, long long r, long long val, long long which) {
      this->l = l;
      this->r = r;
      this->val = val;
      this->which = which;
    }
  } * a;
  int size;
  SegmentTree(int n) {
    n = size = pow(2, ceil(log(n) / log(2)));
    a = new Node[2 * n];
    for (int i = n - 1; i < 2 * n - 1; i++) {
      a[i] = Node(i - n + 1, i - n + 1, 0, i);
    }
    for (int i = n - 2; i > -1; i--)
      a[i] = Node(a[2 * i + 1].l, a[2 * i + 2].r, 0, a[2 * i + 1].which);
  }
  void update(int node, long long x) {
    node = size - 1 + node;
    a[node].val = x;
    while (node) {
      node = (node - 1) / 2;
      a[node].val = max(a[2 * node + 1].val, a[2 * node + 2].val);
      if (a[node].val == a[2 * node + 1].val)
        a[node].which = a[2 * node + 1].which;
      else
        a[node].which = a[2 * node + 2].which;
    }
  }
  int get(int l, int r, int node = 0) {
    int sl = a[node].l, sr = a[node].r;
    int mid = (sl + sr) / 2;
    if (sl == l && sr == r) return a[node].which;
    if (r <= mid)
      return get(l, r, 2 * node + 1);
    else if (l > mid)
      return get(l, r, 2 * node + 2);
    else {
      int x = get(l, mid, 2 * node + 1);
      int y = get(mid + 1, r, 2 * node + 2);
      if (a[x].val > a[y].val)
        return x;
      else
        return y;
    }
  }
  void print() {
    cout << "SegmentTree : " << endl;
    for (int i = 0; i < 2 * size - 1; i++)
      cout << i << ' ' << a[i].l << ' ' << a[i].r << ' ' << a[i].val << ' '
           << a[i].which << endl;
    cout << endl;
  }
};
const int N = 100001;
long long a[N], place[N], last[N];
pair<long long, long long> p[N];
vector<int> final;
int main() {
  int n, d;
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    cin >> p[i].first;
    p[i].second = i;
  }
  sort(p, p + n);
  for (int i = 0; i < n; i++) place[p[i].second] = i, a[i] = p[i].first;
  SegmentTree s(n);
  for (int i = 0; i < n; i++) {
    long long key = a[place[i]];
    int it1 = upper_bound(a, a + n, key - d) - a;
    int it2 = lower_bound(a, a + n, key + d) - a;
    long long ind = 0, maxi = 0;
    if (it1 - 1 >= 0) {
      long long temp = s.get(0, it1 - 1);
      if (s.a[temp].val > maxi) maxi = s.a[temp].val, ind = temp;
    }
    if (it2 < n) {
      int temp = s.get(it2, n - 1);
      if (s.a[temp].val > maxi) maxi = s.a[temp].val, ind = temp;
    }
    ind -= s.size - 1;
    if (!maxi)
      last[i] = i;
    else
      last[i] = p[ind].second;
    maxi++;
    s.update(place[i], maxi);
  }
  int ind = s.get(0, n - 1);
  long long ans = s.a[ind].val;
  cout << ans << endl;
  int node = ind - s.size + 1;
  node = p[node].second;
  for (int i = ans - 1; i > -1; i--) {
    final.push_back(node + 1);
    node = last[node];
  }
  for (int i = final.size() - 1; i > -1; i--) cout << final[i] << ' ';
}
