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>
int n, d;
long long h[100000 + 1];
int p[100000 + 1];
int rank[100000 + 1];
int m;
int size;
long long b[100000 + 1];
int tree1[100000 + 1];
int tree2[100000 + 1];
int f[100000 + 1];
int trace[100000 + 1];
int ans[100000 + 1];
int max(int a, int b) { return (a > b ? a : b); }
void swap(int *a, int *b) {
  int t = *a;
  *a = *b;
  *b = t;
}
void input(void) {
  scanf("%d%d", &n, &d);
  int i;
  for (i = 1; i <= n; i++) {
    scanf("%I64d", &h[i]);
    p[i] = i;
    f[i] = 0;
  }
}
void heapify(int i) {
  int j = i;
  int l, r;
  while (1) {
    l = i << 1;
    r = l + 1;
    if (l <= size) {
      if (h[p[l]] > h[p[j]]) j = l;
      if (r <= size)
        if (h[p[r]] > h[p[j]]) j = r;
    }
    if (i == j) break;
    swap(&p[i], &p[j]);
    i = j;
  }
}
void heapsort(void) {
  size = n;
  int i;
  for (i = n >> 1; i >= 1; i--) heapify(i);
  for (i = n; i >= 2; i--) {
    swap(&p[i], &p[1]);
    size--;
    heapify(1);
  }
}
void init(void) {
  f[0] = 0;
  m = 1;
  b[1] = h[p[1]];
  tree1[1] = tree2[1] = 0;
  rank[p[1]] = 1;
  int i;
  for (i = 2; i <= n; i++) {
    if (h[p[i]] > h[p[i - 1]]) {
      m++;
      b[m] = h[p[i]];
      tree1[m] = tree2[m] = 0;
    }
    rank[p[i]] = m;
  }
}
int get(int i, int *tree) {
  if (i < 1 || i > m) return 0;
  int res = 0;
  while (i > 0) {
    if (f[tree[i]] > f[res]) res = tree[i];
    i -= i & (-i);
  }
  return res;
}
void update(int i, int j, int *tree) {
  if (i < 1 || i > m) return;
  while (i <= m) {
    if (f[j] > f[tree[i]]) tree[i] = j;
    i += i & (-i);
  }
}
int find(long long val) {
  int low = 1, high = m, mid;
  while (low <= high) {
    mid = (low + high) >> 1;
    if (b[mid] < val)
      low = mid + 1;
    else if (b[mid] > val)
      high = mid - 1;
    else
      return mid;
  }
  return 0;
}
int find_upper_bound(long long val) {
  int low = 1, high = m, mid, res = 0;
  while (low <= high) {
    mid = (low + high) >> 1;
    if (b[mid] >= val) {
      res = mid;
      high = mid - 1;
    } else {
      low = mid + 1;
    }
  }
  return res;
}
int find_lower_bound(long long val) {
  int low = 1, high = m, mid, res = 0;
  while (low <= high) {
    mid = (low + high) >> 1;
    if (b[mid] <= val) {
      res = mid;
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return res;
}
void output(void) {
  heapsort();
  init();
  int i, x, y, z, k, p, q;
  for (i = 1; i <= n; i++) {
    x = find(h[i]);
    y = find_lower_bound(h[i] - d);
    z = find_upper_bound(h[i] + d);
    p = get(y, tree1);
    q = get(m - z + 1, tree2);
    if (f[p] > f[q])
      k = p;
    else
      k = q;
    if (f[k] + 1 > f[i]) {
      f[i] = f[k] + 1;
      trace[i] = k;
      update(x, i, tree1);
      update(m - x + 1, i, tree2);
    }
  }
  x = get(m, tree1);
  k = x;
  for (i = f[x]; i >= 1; i--) {
    ans[i] = k;
    k = trace[k];
  }
  printf("%d\n", f[x]);
  for (i = 1; i <= f[x]; i++) printf("%d ", ans[i]);
  printf("\n");
}
int main(void) {
  input();
  output();
  return 0;
}
