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, D;
long long H[200000];
set<long long> s;
map<long long, int> m;
int DP[200000] = {0};
int fa[200000];
struct Node {
  Node *l, *r;
  int fa;
};
void build(Node *&O, int L, int R) {
  O = new Node();
  O->fa = N + 1;
  if (L + 1 == R) return;
  build(O->l, L, (L + R) / 2);
  build(O->r, (L + R) / 2, R);
}
int ask(Node *O, int L, int R, int A, int B) {
  if (B <= L || R <= A)
    return 0;
  else if (A <= L && R <= B)
    return O->fa;
  else {
    int v1 = ask(O->l, L, (L + R) / 2, A, B);
    int v2 = ask(O->r, (L + R) / 2, R, A, B);
    return DP[v1] >= DP[v2] ? v1 : v2;
  }
}
void ch(Node *O, int L, int R, int A, int B, int i) {
  if (B <= L || R <= A)
    return;
  else if (A <= L && R <= B) {
    O->fa = DP[O->fa] >= DP[i] ? O->fa : i;
  } else {
    ch(O->l, L, (L + R) / 2, A, B, i);
    ch(O->r, (L + R) / 2, R, A, B, i);
    O->fa = DP[O->l->fa] >= DP[O->r->fa] ? O->l->fa : O->r->fa;
    return;
  }
}
Node *root;
int main() {
  scanf("%d %d", &N, &D);
  for (int Ni = 1; Ni <= N; Ni++) cin >> H[Ni], s.insert(H[Ni]);
  int n = 0;
  s.insert(2e15);
  for (set<long long>::iterator it = s.begin(); it != s.end(); it++)
    m[*it] = n++;
  build(root, 0, n);
  for (int Ni = N; Ni >= 1; Ni--) {
    int t = N + 1;
    long long u = m[*s.lower_bound(H[Ni] + D)];
    t = DP[ask(root, 0, n, u, n)] > DP[t] ? ask(root, 0, n, u, n) : t;
    long long d = m[*s.upper_bound(H[Ni] - D)];
    t = DP[ask(root, 0, n, 0, d)] > DP[t] ? ask(root, 0, n, 0, d) : t;
    DP[Ni] = DP[t] + 1;
    fa[Ni] = t;
    ch(root, 0, n, m[H[Ni]], m[H[Ni]] + 1, Ni);
  }
  int Ans = 1;
  for (int Ni = 1; Ni <= N; Ni++)
    if (DP[Ni] > DP[Ans]) Ans = Ni;
  printf("%d", DP[Ans]);
  puts("");
  for (int i = Ans, flag = 0; i != N + 1; i = fa[i]) {
    if (flag) printf(" ");
    flag = 1;
    printf("%d", i);
  }
  puts("");
}
