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 n;
long long d;
const int MAXN = 100 * 1000 + 9;
int dp[MAXN];
long long h[MAXN];
long long h_sort[MAXN];
struct node {
  int val, pos;
  node(int v = 0, int p = 0) : val(v), pos(p) {}
};
node unite(const node& A, const node& B) {
  if (A.val > B.val)
    return A;
  else
    return B;
}
struct seg_tree {
  int pow2;
  node* A;
  seg_tree(int nn) {
    pow2 = 1;
    while (pow2 < nn) pow2 *= 2;
    A = new node[pow2 * 2];
    for (int i = 0; i < nn; i++) A[i + pow2] = node(0, i);
    for (int i = pow2 - 1; i >= 1; i--) A[i] = unite(A[2 * i], A[2 * i + 1]);
  }
  node mx_query(int L, int R) { return mx_query(L, R, 1, 0, pow2 - 1); }
  node mx_query(int L, int R, int ind, int LB, int RB) {
    if (L > R) return 0;
    if (LB == L && R == RB) return A[ind];
    int MB = (LB + RB) / 2;
    return unite(mx_query(L, min(MB, R), ind * 2, LB, MB),
                 mx_query(max(MB + 1, L), R, ind * 2 + 1, MB + 1, RB));
  }
  void update(int ind, int val) {
    ind += pow2;
    A[ind].val = val;
    while (ind > 1) {
      ind /= 2;
      A[ind] = unite(A[ind * 2], A[ind * 2 + 1]);
    }
  }
  ~seg_tree() { delete[] A; }
};
int bin_search_hi(long long val) {
  int L = 0, R = n - 1, M;
  while (R - L > 1) {
    M = (L + R) / 2;
    if (val <= h_sort[M])
      R = M;
    else
      L = M;
  }
  if (val <= h_sort[L]) return L;
  if (val <= h_sort[R]) return R;
  return -1;
}
int bin_search_lo(long long val) {
  int L = 0, R = n - 1, M;
  while (R - L > 1) {
    M = (L + R) / 2;
    if (h_sort[M] <= val)
      L = M;
    else
      R = M;
  }
  if (h_sort[R] <= val) return R;
  if (h_sort[L] <= val) return L;
  return -1;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cin >> n >> d;
  for (int i = 0; i < n; i++) {
    cin >> h[i];
    h_sort[i] = h[i];
  }
  sort(h_sort, h_sort + n);
  seg_tree T(n);
  for (int i = n - 1; i >= 0; i--) {
    dp[i] = 1;
    long long hi = h[i] + d;
    int ind = bin_search_hi(hi);
    if (ind != -1) {
      node mx = T.mx_query(ind, n - 1);
      if (mx.val + 1 > dp[i]) {
        dp[i] = mx.val + 1;
      }
    }
    long long lo = h[i] - d;
    ind = bin_search_lo(lo);
    if (ind != -1) {
      node mx = T.mx_query(0, ind);
      if (mx.val + 1 > dp[i]) {
        dp[i] = mx.val + 1;
      }
    }
    ind = bin_search_hi(h[i]);
    T.update(ind, dp[i]);
  }
  int best = 0;
  for (int i = 0; i < n; i++)
    if (dp[i] > dp[best]) best = i;
  cout << dp[best] << '\n';
  int curr = best;
  while (curr < n) {
    cout << curr + 1 << ' ';
    int prev = curr;
    curr++;
    while (curr < n && (dp[prev] != dp[curr] + 1 || abs(h[prev] - h[curr]) < d))
      curr++;
  }
  return 0;
}
