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 h[100005], d;
int dp[100005];
int arr[300003];
int tree[(1200004)];
int lazy[(1200004)];
void build_tree(int node, int a, int b) {
  if (a > b) return;
  if (a == b) {
    tree[node] = arr[a];
    return;
  }
  build_tree(node * 2, a, (a + b) / 2);
  build_tree(node * 2 + 1, 1 + (a + b) / 2, b);
  tree[node] = max(tree[node * 2], tree[node * 2 + 1]);
}
void update_tree(int node, int a, int b, int i, int j, int value) {
  if (lazy[node] != 0) {
    tree[node] += lazy[node];
    if (a != b) {
      lazy[node * 2] += lazy[node];
      lazy[node * 2 + 1] += lazy[node];
    }
    lazy[node] = 0;
  }
  if (a > b || a > j || b < i) return;
  if (a >= i && b <= j) {
    tree[node] += value;
    if (a != b) {
      lazy[node * 2] += value;
      lazy[node * 2 + 1] += value;
    }
    return;
  }
  update_tree(node * 2, a, (a + b) / 2, i, j, value);
  update_tree(1 + node * 2, 1 + (a + b) / 2, b, i, j, value);
  tree[node] = max(tree[node * 2], tree[node * 2 + 1]);
}
int query_tree(int node, int a, int b, int i, int j) {
  if (a > b || a > j || b < i) return -0x7fffffff;
  if (lazy[node] != 0) {
    tree[node] += lazy[node];
    if (a != b) {
      lazy[node * 2] += lazy[node];
      lazy[node * 2 + 1] += lazy[node];
    }
    lazy[node] = 0;
  }
  if (a >= i && b <= j) return tree[node];
  int q1 = query_tree(node * 2, a, (a + b) / 2, i, j);
  int q2 = query_tree(1 + node * 2, 1 + (a + b) / 2, b, i, j);
  int res = max(q1, q2);
  return res;
}
void reconstruct(vector<int>& ret, int val) {
  long long last = -1e18;
  for (int i = 0; i < n; i++) {
    if (abs(last - h[i]) >= d && dp[i] == val) {
      ret.push_back(i + 1);
      last = h[i];
      val--;
    }
  }
}
map<long long, int> htoi;
set<long long> ss;
int main() {
  cin >> n >> d;
  int counter = 0;
  for (int i = 0; i < n; i++) {
    scanf("%I64d", &h[i]);
    ss.insert(h[i]);
  }
  set<long long>::iterator iit;
  for (iit = ss.begin(); iit != ss.end(); iit++) htoi[*iit] = counter++;
  ss.clear();
  update_tree(1, 0, 300003 - 1, htoi[h[n - 1]], htoi[h[n - 1]], 1);
  ss.insert(h[n - 1]);
  dp[n - 1] = 1;
  for (int ind = n - 2; ind >= 0; ind--) {
    int index = htoi[h[ind]];
    long long curmin = *ss.begin();
    iit = ss.end();
    iit--;
    long long curmax = *iit;
    int ucand = 0;
    int dcand = 0;
    if (ss.lower_bound(h[ind] + d) != ss.end()) {
      long long curhplud = *ss.lower_bound(h[ind] + d);
      ucand = max(ucand,
                  query_tree(1, 0, 300003 - 1, htoi[curhplud], htoi[curmax]));
    }
    iit = ss.lower_bound(h[ind] - d);
    if (iit == ss.begin()) {
      if (*iit <= h[ind] - d) {
        dcand = max(dcand,
                    query_tree(1, 0, 300003 - 1, htoi[curmin], htoi[curmin]));
      }
    } else {
      if (*iit > h[ind] - d) iit--;
      if (iit == ss.end()) iit--;
      long long curhmind = *iit;
      dcand = max(dcand,
                  query_tree(1, 0, 300003 - 1, htoi[curmin], htoi[curhmind]));
    }
    int curval = query_tree(1, 0, 300003 - 1, index, index);
    int newval = max(max(ucand, dcand) + 1, curval);
    update_tree(1, 0, 300003 - 1, index, index, newval - curval);
    ss.insert(h[ind]);
    dp[ind] = query_tree(1, 0, 300003 - 1, index, index);
  }
  int len = dp[0];
  for (int i = 1; i < n; i++) len = max(len, dp[i]);
  vector<int> ret;
  reconstruct(ret, len);
  cout << ret.size() << endl;
  for (int i = 0; i < ret.size(); i++) cout << ret[i] << ' ';
  cout << endl;
  return 0;
}
