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;
vector<long long> h;
long long d;
int dp[100030];
const int MIN = -987654321;
struct RMQ {
  int n;
  vector<int> rangeMin;
  RMQ(const vector<int>& arr) {
    n = arr.size();
    rangeMin.resize(n * 4);
    init(arr, 0, n - 1, 1);
  }
  int init(const vector<int>& arr, int left, int right, int node) {
    if (left == right) return rangeMin[node] = arr[left];
    int mid = (left + right) / 2;
    int leftMin = init(arr, left, mid, node * 2);
    int rightMin = init(arr, mid + 1, right, node * 2 + 1);
    return rangeMin[node] = max(leftMin, rightMin);
  }
  int query(int left, int right, int node, int nodeLeft, int nodeRight) {
    if (right < nodeLeft || left > nodeRight) return MIN;
    if (left <= nodeLeft && nodeRight <= right) return rangeMin[node];
    int mid = (nodeLeft + nodeRight) / 2;
    return max(query(left, right, node * 2, nodeLeft, mid),
               query(left, right, node * 2 + 1, mid + 1, nodeRight));
  }
  int query(int left, int right) { return query(left, right, 1, 0, n - 1); }
  int update(int index, int newValue, int node, int nodeLeft, int nodeRight) {
    if (nodeLeft > index || index > nodeRight) return rangeMin[node];
    if (nodeLeft == nodeRight) return rangeMin[node] = newValue;
    int mid = (nodeLeft + nodeRight) / 2;
    return rangeMin[node] =
               max(update(index, newValue, node * 2, nodeLeft, mid),
                   update(index, newValue, node * 2 + 1, mid + 1, nodeRight));
  }
  int update(int index, int newValue) {
    return update(index, newValue, 1, 0, n - 1);
  }
};
void reconstruct(vector<int>& ret, int val) {
  long long last = -1e17;
  for (int i = 0; i < n; i++) {
    long long cand = last - h[i];
    if (cand < 0) cand = -cand;
    if (cand >= d && dp[i] == val) {
      ret.push_back(i + 1);
      last = h[i];
      val--;
    }
  }
}
map<long long, int> htoi;
set<long long> ss;
const long long zero = 0;
const long long maxi = 1e18;
const long long mini = -1e18;
int main() {
  int counter = 0;
  for (int i = 0; i < 100030; i++) {
    dp[i] = 0;
  }
  h = vector<long long>(100030, zero);
  vector<int> arr(h.size(), 0);
  RMQ rmq(arr);
  scanf("%d %I64d", &n, &d);
  for (int i = 0; i < n; i++) {
    scanf("%I64d", &h[i]);
    ss.insert(h[i]);
  }
  ss.insert(maxi);
  ss.insert(mini);
  set<long long>::iterator iit;
  for (iit = ss.begin(); iit != ss.end(); iit++) {
    htoi[*iit] = counter;
    counter++;
  }
  ss.clear();
  ss.insert(mini);
  ss.insert(maxi);
  for (int ind = n - 1; ind >= 0; ind--) {
    int index = htoi[h[ind]];
    int ucand = 0;
    int dcand = 0;
    long long curhplud = *(ss.lower_bound(h[ind] + d));
    ucand = max(ucand, rmq.query(htoi[curhplud], htoi[maxi]));
    iit = ss.lower_bound(h[ind] - d);
    if ((*iit) > (h[ind] - d)) iit--;
    long long curhmind = *iit;
    dcand = max(dcand, rmq.query(htoi[mini], htoi[curhmind]));
    int newval = max(ucand, dcand) + 1;
    rmq.update(index, newval);
    ss.insert(h[ind]);
    dp[ind] = newval;
  }
  int len = dp[0];
  for (int i = 1; i < n; i++) len = max(len, dp[i]);
  vector<int> ret;
  reconstruct(ret, len);
  cout << len << endl;
  for (int i = 0; i < ret.size(); i++) cout << ret[i] << ' ';
  cout << endl;
  return 0;
}
