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 treap_t {
  long long value, priority, length, answer, self_position, position;
  treap_t *left, *right;
  treap_t(long long value, long long length, long long position)
      : value(value),
        priority(rand()),
        length(length),
        answer(length),
        self_position(position),
        position(position),
        left(nullptr),
        right(nullptr) {}
};
long long get_answer(treap_t *root) { return root ? root->answer : 0; }
long long get_position(treap_t *root) { return root ? root->position : -1; }
void update_answer(treap_t *root) {
  if (root) {
    root->answer = root->length;
    root->position = root->self_position;
    long long lanswer = get_answer(root->left);
    long long ranswer = get_answer(root->right);
    if (lanswer > root->answer) {
      root->position = get_position(root->left);
      root->answer = lanswer;
    }
    if (ranswer > root->answer) {
      root->position = get_position(root->right);
      root->answer = ranswer;
    }
  }
}
void split(treap_t *root, long long h, treap_t *&left, treap_t *&right) {
  if (!root) {
    left = right = nullptr;
  } else if (root->value < h) {
    split(root->right, h, root->right, right);
    left = root;
    update_answer(left);
  } else {
    split(root->left, h, left, root->left);
    right = root;
    update_answer(right);
  }
}
treap_t *merge(treap_t *left, treap_t *right) {
  treap_t *root = nullptr;
  if (!left || !right) {
    root = left ? left : right;
  } else if (left->priority > right->priority) {
    left->right = merge(left->right, right);
    root = left;
  } else {
    right->left = merge(left, right->left);
    root = right;
  }
  update_answer(root);
  return root;
}
treap_t *insert(treap_t *root, treap_t *newbie) {
  if (!root) return newbie;
  treap_t *left, *right;
  split(root, newbie->value, left, right);
  return merge(merge(left, newbie), right);
}
int main() {
  ios_base::sync_with_stdio(false);
  int n;
  long long d;
  cin >> n >> d;
  vector<long long> h(n);
  for (size_t i = 0; i < h.size(); ++i) {
    cin >> h[i];
  }
  vector<long long> parent(n), answer(n);
  for (size_t i = 0; i < parent.size(); ++i) {
    parent[i] = -1;
    answer[i] = 1;
  }
  treap_t *root = nullptr;
  for (size_t i = 0; i < h.size(); ++i) {
    treap_t *left, *middle, *right;
    split(root, h[i] - d + 1, left, middle);
    split(middle, h[i] + d, middle, right);
    if (get_answer(left) + 1 > answer[i]) {
      answer[i] = get_answer(left) + 1;
      parent[i] = get_position(left);
    }
    if (get_answer(right) + 1 > answer[i]) {
      answer[i] = get_answer(right) + 1;
      parent[i] = get_position(right);
    }
    root = merge(merge(left, middle), right);
    root = insert(root, new treap_t(h[i], answer[i], i));
  }
  cout << get_answer(root) << endl;
  long long position = get_position(root);
  vector<long long> pos;
  while (position != -1) {
    pos.push_back(position);
    position = parent[position];
  }
  reverse(pos.begin(), pos.end());
  for (size_t i = 0; i < pos.size(); ++i) {
    cout << pos[i] + 1 << ' ';
  }
  cout << endl;
  return 0;
}
