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 Node {
  long long h;
  int ls;
  int id;
};
const int MAX_N = int(1e5) + 5;
const int MAX_NNN = MAX_N * 3;
const int MAX_T = MAX_NNN << 2;
Node node[MAX_NNN];
int dp[MAX_N];
int tree[MAX_T];
int pre[MAX_N];
bool h_order(const Node& a, const Node& b) { return a.h < b.h; }
bool id_order(const Node& a, const Node& b) { return a.id < b.id; }
int better(int i, int j) {
  if (i == -1) return j;
  if (j == -1) return i;
  return dp[i] > dp[j] ? i : j;
}
void build(int l, int r, int id) { memset(tree, -1, sizeof(tree)); }
int query(int l, int r, int id, int ql, int qr) {
  if (ql <= l && r <= qr) return tree[id];
  if (l == r) return -1;
  int max_dp = 0;
  int p = -1;
  int mid = (l + r) >> 1;
  if (ql <= mid) p = better(p, query(l, mid, id << 1, ql, qr));
  if (mid < qr) p = better(p, query(mid + 1, r, id << 1 | 1, ql, qr));
  return p;
}
void update(int l, int r, int id, int pos, int c) {
  if (l == r) {
    assert(l == pos);
    if (tree[id] == -1 || dp[c] > dp[tree[id]]) tree[id] = c;
    return;
  }
  int mid = (l + r) >> 1;
  if (pos <= mid)
    update(l, mid, id << 1, pos, c);
  else
    update(mid + 1, r, id << 1 | 1, pos, c);
  tree[id] = better(tree[id << 1], tree[id << 1 | 1]);
}
void print_trace(int i) {
  if (i == -1) return;
  print_trace(pre[i]);
  printf("%d ", i);
}
int main() {
  int n, d;
  scanf("%d %d", &n, &d);
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &node[i].h);
    node[i].id = i;
    node[n + i * 2 - 1].h = node[i].h - d;
    node[n + i * 2].h = node[i].h + d;
    node[n + i * 2 - 1].id = n + i * 2 - 1;
    node[n + i * 2].id = n + i * 2;
  }
  sort(node + 1, node + 3 * n + 1, h_order);
  node[1].ls = 1;
  int now = 1;
  for (int i = 2; i <= 3 * n; i++) {
    if (node[i].h == node[i - 1].h)
      node[i].ls = now;
    else
      node[i].ls = ++now;
  }
  sort(node + 1, node + 3 * n + 1, id_order);
  build(1, now, 1);
  for (int i = 1; i <= n; i++) {
    int low = node[n + 2 * i - 1].ls;
    int upp = node[n + 2 * i].ls;
    int j = better(query(1, now, 1, 1, low), query(1, now, 1, upp, now));
    if (j == -1)
      dp[i] = 1;
    else
      dp[i] = dp[j] + 1;
    pre[i] = j;
    update(1, now, 1, node[i].ls, i);
  }
  int p = 1;
  for (int i = 2; i <= n; i++)
    if (dp[i] > dp[p]) p = i;
  printf("%d\n", dp[p]);
  print_trace(p);
  return 0;
}
