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 MAX = 1e5 + 7;
int n, d;
long long h[MAX];
int dp[MAX];
int len = 0;
long long ele[MAX];
int Max[MAX << 2];
int last[MAX];
int ret = 0, rid;
int seq[MAX];
int key(long long x) { return lower_bound(ele, ele + len, x) - ele + 1; }
void push_up(int rt) { Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]); }
void build(int l, int r, int rt) {
  if (l == r) {
    Max[rt] = 0;
    return;
  }
  int m = (l + r) >> 1;
  build(l, m, rt << 1);
  build(m + 1, r, rt << 1 | 1);
  push_up(rt);
}
void update(int p, int l, int r, int rt, int v, int i) {
  if (l == r) {
    if (Max[rt] < v) {
      Max[rt] = v;
    }
    return;
  }
  int m = (l + r) >> 1;
  if (p <= m)
    update(p, l, m, rt << 1, v, i);
  else
    update(p, m + 1, r, rt << 1 | 1, v, i);
  push_up(rt);
}
void query(int ql, int qr, int l, int r, int rt) {
  if (ql <= l && qr >= r) {
    if (Max[rt] > ret) {
      ret = Max[rt];
    }
    return;
  }
  int m = (l + r) >> 1;
  if (ql <= m) query(ql, qr, l, m, rt << 1);
  if (qr > m) query(ql, qr, m + 1, r, rt << 1 | 1);
}
int main() {
  scanf("%d%d", &n, &d);
  for (int i = 0; i < n; ++i) {
    cin >> h[i];
    ele[len++] = h[i];
    dp[i] = 1;
    last[i] = -1;
  }
  sort(ele, ele + len);
  int t = unique(ele, ele + len) - ele;
  len = t;
  build(1, len, 1);
  int ans = 0;
  update(key(h[0]), 1, len, 1, 1, 0);
  for (int i = 1; i < n; ++i) {
    ret = 0;
    int z = key(h[i] - d);
    if (ele[z - 1] != h[i] - d) z--;
    if (z != 0) {
      ret = 0;
      query(1, z, 1, len, 1);
      dp[i] = max(dp[i], ret + 1);
    }
    if (h[i] + d <= ele[len - 1]) {
      z = key(h[i] + d);
      ret = 0;
      query(z, len, 1, len, 1);
      dp[i] = max(dp[i], ret + 1);
    }
    update(key(h[i]), 1, len, 1, dp[i], i);
    ans = max(ans, dp[i]);
  }
  printf("%d\n", ans);
  int u;
  for (int i = 0; i < n; ++i)
    if (dp[i] == ans) {
      u = i;
    }
  int len1 = 0;
  seq[len1++] = u;
  int j = u - 1;
  while (j >= 0) {
    if (dp[j] + 1 == dp[u] && abs(h[u] - h[j]) >= d) {
      seq[len1++] = j;
      u = j;
    }
    --j;
  }
  for (int i = len1 - 1; i >= 0; --i) {
    printf("%d%c", seq[i] + 1, i == 0 ? '\n' : ' ');
  }
  return 0;
}
