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;
long long d;
long long a[100005 + 1];
vector<long long> b;
map<long long, int> c;
int dp[100005 + 1];
int bt[100005 + 1];
int locc[100005 + 1];
int an[100005 + 1];
int que(int l, int r) {
  int p, q, m = 0;
  for (p = r - (r & -r); l <= r; r = p, p -= p & -p) {
    q = (p + 1 >= l) ? bt[r] : (p = r - 1) + 1;
    if (dp[m] < dp[q]) m = q;
  }
  return m;
}
void upd(int x) {
  int y, z;
  for (y = x; x <= 100005; x += x & -x)
    if (bt[x] == y) {
      z = que(x - (x & -x) + 1, x - 1);
      bt[x] = (dp[z] > dp[x]) ? z : x;
    } else if (dp[bt[x]] < dp[y])
      bt[x] = y;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin >> n;
  cin >> d;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    b.push_back(a[i]);
  }
  b.push_back(-2e16);
  b.push_back(-2e15);
  b.push_back(2e15);
  sort(b.begin(), b.end());
  b.erase(unique(b.begin(), b.end()), b.end());
  int p = b.size() - 1;
  for (int i = 1; i <= p; i++) c[b[i]] = i;
  int ans = 0, nas = 0;
  for (int i = 1; i <= n; i++) {
    int r1 = lower_bound(b.begin(), b.end(), a[i] + d) - b.begin();
    int s1 = que(r1, p);
    int r2 = upper_bound(b.begin(), b.end(), a[i] - d) - b.begin() - 1;
    int s2 = que(1, r2);
    if (max(dp[s1], dp[s2]) + 1 <= dp[c[a[i]]]) continue;
    if (dp[s1] > dp[s2]) {
      dp[c[a[i]]] = dp[s1] + 1;
      an[i] = locc[s1];
    } else {
      dp[c[a[i]]] = dp[s2] + 1;
      an[i] = locc[s2];
    }
    upd(c[a[i]]);
    if (dp[c[a[i]]] > ans) {
      ans = dp[c[a[i]]];
      nas = i;
    }
    locc[c[a[i]]] = i;
  }
  cout << ans << endl;
  vector<int> topi;
  for (int i = 0; i < ans; i++) {
    topi.push_back(nas);
    nas = an[nas];
  }
  reverse(topi.begin(), topi.end());
  for (int i = 0; i < ans; i++) cout << topi[i] << " ";
  cout << endl;
  return 0;
}
