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>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse")
#pragma GCC target("sse2")
#pragma GCC target("ssse3")
#pragma GCC target("sse4")
#pragma GCC target("abm")
#pragma GCC target("avx")
#pragma GCC target("avx2")
#pragma GCC target("mmx")
#pragma GCC target("popcnt")
#pragma GCC target("tune=native")
using namespace std;
const long long mxn = 1e5 + 5;
long long n, d, mx = 0, GGL;
long long ans[mxn], idx_ans[mxn], idx[mxn];
long long q, k;
pair<long long, long long> sorted_arr[mxn];
map<pair<long long, long long>, long long> mp;
struct item {
  long long mx, mn, ans, idx, i;
};
struct segtree {
  int size;
  vector<item> v;
  item NE = {0, (long long)1e16, 0, -1, -1};
  void init(int n) {
    size = 1;
    while (size < n) {
      size *= 2;
    }
    v.assign(2 * size, NE);
  }
  item merge(item a, item b) {
    item ans = a;
    if (b.ans > a.ans) {
      ans.ans = b.ans;
      ans.idx = b.idx;
      ans.i = b.i;
    }
    if (b.mx > a.mx) {
      ans.mx = b.mx;
    }
    if (b.mn < a.mn) {
      ans.mn = b.mn;
    }
    return ans;
  }
  void set(int i, int ans, long long k, int id, int x, int lx, int rx) {
    if (lx + 1 == rx) {
      v[x] = {k, k, ans, i, id};
      return;
    }
    int m = (lx + rx) / 2;
    if (i < m) {
      set(i, ans, k, id, 2 * x + 1, lx, m);
    } else {
      set(i, ans, k, id, 2 * x + 2, m, rx);
    }
    v[x] = merge(v[2 * x + 1], v[2 * x + 2]);
  }
  void set(int i, int ans, long long k, int id) {
    set(i, ans, k, id, 0, 0, size);
  }
  item calc(long long k, int x, int lx, int rx) {
    int m = (lx + rx) / 2;
    if (v[x].mx <= k) {
      return v[x];
    } else if (v[x].mn > k) {
      return NE;
    } else {
      item ans1 = calc(k, 2 * x + 1, lx, m);
      item ans2 = calc(k, 2 * x + 2, m, rx);
      ans1 = merge(ans1, ans2);
      return ans1;
    }
  }
  item calc(long long k) { return calc(k, 0, 0, size); }
  item calc2(long long k, int x, int lx, int rx) {
    int m = (lx + rx) / 2;
    if (v[x].mx < k) {
      return NE;
    } else if (v[x].mn >= k) {
      return v[x];
    } else {
      item ans1 = calc2(k, 2 * x + 1, lx, m);
      item ans2 = calc2(k, 2 * x + 2, m, rx);
      ans1 = merge(ans1, ans2);
      return ans1;
    }
  }
  item calc2(long long k) { return calc2(k, 0, 0, size); }
};
void input() {
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    cin >> q;
    sorted_arr[i] = (make_pair(q, i));
    idx[i] = q;
  }
}
void solve() {
  segtree st;
  st.init(n);
  sort(sorted_arr, sorted_arr + n);
  for (int i = 0; i < n; i++) {
    mp[make_pair(sorted_arr[i].first, sorted_arr[i].second)] = i;
  }
  item a, b;
  for (int i = n - 1; i > -1; i--) {
    k = idx[i] - d;
    a = st.calc(k);
    k = idx[i] + d;
    b = st.calc2(k);
    if (a.ans < b.ans) {
      a = b;
    }
    q = mp[make_pair(idx[i], i)];
    st.set(q, a.ans + 1, idx[i], i);
    ans[q] = a.ans + 1;
    idx_ans[i] = a.i + 1;
    if (idx_ans[i] == 0) {
      idx_ans[i] = i + 1;
    }
    if (ans[q] > mx) {
      mx = ans[q];
      GGL = i + 1;
    }
  }
  cout << mx << endl;
  cout << GGL << ' ';
  for (int i = 0; i < mx - 1; i++) {
    GGL = idx_ans[GGL - 1];
    cout << GGL << " ";
  }
  return;
}
int main() {
  ios::sync_with_stdio(false);
  input(), solve();
  return 0;
}
