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 N = 100010;
const int M = 200010;
long long a[N];
struct Node* null;
struct Node {
  Node* c[2];
  Node* fa;
  long long h;
  int val;
  int id;
  int mx, idx;
  inline void setc(int d, Node* s) {
    c[d] = s;
    s->fa = this;
  }
  inline bool d() { return fa->c[1] == this; }
  void up() {
    if (this == null) return;
    mx = val;
    idx = id;
    if (c[0]->mx > mx) mx = c[0]->mx, idx = c[0]->idx;
    if (c[1]->mx > mx) mx = c[1]->mx, idx = c[1]->idx;
  }
  void clear() { c[0] = c[1] = fa = null; }
} node[N * 20], *pool;
int pre[N], dp[N];
struct SplayTree {
  Node* root;
  void rot(Node* x) {
    Node* p = x->fa;
    int f = x->d();
    p->fa->setc(p->d(), x);
    p->setc(f, x->c[!f]);
    x->setc(!f, p);
    p->up();
  }
  void splay(Node* x, Node* goal) {
    while (x->fa != goal) {
      if (x->fa->fa == goal) {
        rot(x);
      } else {
        x->d() == (x->fa->d()) ? rot(x->fa) : rot(x);
        rot(x);
      }
    }
    x->up();
    if (goal == null) {
      root = x;
    }
  }
  void insert(long long depth, int value, int ind) {
    if (root == null) {
      Node* tmp = pool++;
      tmp->clear();
      tmp->val = value;
      tmp->id = ind;
      tmp->idx = ind;
      tmp->h = depth;
      tmp->mx = value;
      root = tmp;
      return;
    }
    Node* x = root;
    Node* p = null;
    int c = -1;
    while (x != null) {
      p = x;
      if (x->h < depth) {
        x = x->c[1];
        c = 1;
      } else {
        x = x->c[0];
        c = 0;
      }
    }
    Node* tmp = pool++;
    tmp->clear();
    tmp->val = value;
    tmp->id = ind;
    tmp->h = depth;
    p->setc(c, tmp);
    splay(tmp, null);
  }
  pair<int, int> queryR(long long d) {
    int ret = 0, mx = 0;
    Node* x = root;
    Node* p = null;
    while (x != null) {
      p = x;
      if (x->h >= d) {
        if (x->c[1]->mx > mx) {
          mx = x->c[1]->mx;
          ret = x->c[1]->idx;
        }
        if (x->val > mx) {
          mx = x->val;
          ret = x->id;
        }
        x = x->c[0];
      } else {
        x = x->c[1];
      }
    }
    if (p != null) splay(p, null);
    return make_pair(ret, mx);
  }
  pair<int, int> queryL(long long d) {
    int ret = 0, mx = 0;
    Node* x = root;
    Node* p = null;
    while (x != null) {
      p = x;
      if (x->h <= d) {
        if (x->c[0]->mx > mx) {
          mx = x->c[0]->mx;
          ret = x->c[0]->idx;
        }
        if (x->val > mx) {
          mx = x->val;
          ret = x->id;
        }
        x = x->c[1];
      } else {
        x = x->c[0];
      }
    }
    if (p != null) splay(p, null);
    return make_pair(ret, mx);
  }
  void init() { root = null; }
} spt;
int f[N];
long long Abs(long long x) {
  if (x < 0) return -x;
  return x;
}
int main() {
  null = new Node();
  null->clear();
  null->mx = -1;
  null->val = -1;
  null->h = -1;
  null->idx = null->id = -1;
  int n, d;
  scanf("%d%d", &n, &d);
  spt.init();
  pool = node;
  memset(pre, -1, sizeof(pre));
  int mx = 0, id = -1;
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &a[i]);
    dp[i] = 1;
    if (i == 1) {
      spt.insert(a[1], 1, 1);
    } else {
      long long tmp1 = a[i] - d;
      long long tmp2 = a[i] + d;
      pair<int, int> p1 = spt.queryL(tmp1);
      if (p1.second + 1 > dp[i]) {
        dp[i] = p1.second + 1;
        pre[i] = p1.first;
      }
      pair<int, int> p2 = spt.queryR(tmp2);
      if (p2.second + 1 > dp[i]) {
        dp[i] = p2.second + 1;
        pre[i] = p2.first;
      }
      spt.insert(a[i], dp[i], i);
    }
    if (dp[i] > mx) {
      mx = dp[i];
      id = i;
    }
  }
  if (id == -1)
    while (1)
      ;
  printf("%d\n", dp[id]);
  vector<int> ret;
  for (int p = id; p != -1; p = pre[p]) {
    ret.push_back(p);
  }
  reverse(ret.begin(), ret.end());
  for (int i = 0; i < ret.size(); i++) {
    if (i) {
      printf(" ");
      if (Abs(a[ret[i]] - a[ret[i - 1]]) < d) {
        while (1)
          ;
      }
    }
    printf("%d", ret[i]);
  }
  return 0;
}
