// author: gary
#include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ( (int) (x).size() )
#define DBG(x) do { std::cerr << #x << ": " << x << std::endl; } while (0)
typedef pair<int, int> pii;
typedef long long ll;
template<class T> bool cmax(T& a, T b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool cmin(T& a, T b) { if(a > b) { a = b; return true; } return false; }
#define prev hsdf
#define bset(x, i) (((x)>>(i))&1)
const int N = 1e5 + 10;
const int B = 30;

const int INF = 1e9+10;
const int MIN = 0;
const int MAX = 1;

int  T[N*4];
int mx[N*4], mn[N*4]; 
int lx[N*4], ln[N*4];

void push(int n, int L, int R) {
  if(mx[n] < lx[n]) T[n] += lx[n] - mx[n], mx[n] = lx[n];
  if(mn[n] > ln[n]) T[n] += mn[n] - ln[n], mn[n] = ln[n];
  if(L < R) {
    cmax(lx[n*2], lx[n]), cmax(lx[n*2+1], lx[n]);
    cmin(ln[n*2], ln[n]), cmin(ln[n*2+1], ln[n]);
  }
  lx[n] = 0, ln[n] = +INF;
}

void update(int n, int L, int R, int i, int j, int x) {
  push(n, L, R);
  if(j < L || R < i) return;
  if(i <= L && R <= j) {
    lx[n] = x, ln[n] = x;
    push(n, L, R);
  } else {
    int m = (L + R) / 2;
    update(n*2, L, m, i, j, x);
    update(n*2+1, m+1, R, i, j, x);
    T[n] = min(T[n*2], T[n*2+1]);
  }
}

int query(int n, int L, int R, int i, int j, int x) {
  push(n, L, R);
  if(x < T[n] || j < L || R < i)
    return INF;
  if(L == R)
    return L;
  int m = (L + R) / 2;
  int l = query(n * 2, L, m, i, j, x);
  if(l != INF)
    return l;
  return query(n * 2 + 1, m+1, R, i, j, x);
}

int n, a[N];
int prev[N][2][B];
int ans[N];

// Find lowest index in [i...j] such that max-min >= x
int query(int i, int j, int x) {
  if(x < 0) return INF;
  // printf("Query(%d, %d) x = %d T[1]=%d\n", i, j, x, T[1]);
  return query(1, 1, n, i, j, x);
}

void update(int i, int x) { update(1, 1, n, 1, i, x); }

int main() {
  int min_cost;
  scanf("%d%d", &n, &min_cost);
  for(int i = 1; i <= n; i++) 
    scanf("%d", a + i);

  fill(lx, lx + 4 * N, 0); fill(ln, ln + 4 * N, +INF);
  fill(mx, mx + 4 * N, 0); fill(mn, mn + 4 * N, +INF);
  fill(T, T + 4 * N, -INF);

  for(int i = 1; i <= n; i++) {
    for(int j = 0; j < 2; j++) {
      for(int k = 0; k < B; k++) {
        prev[i][j][k] = prev[i-1][j][k];
      }
    }
    for(int k = 0; k < B; k++) {
      prev[i][bset(a[i], k)][k] = i;
    }
  }

  memset(ans, -1, sizeof ans);

  for(int i = 1; i <= n; i++) {
    update(i, a[i]);

    int cur = i;
    int maskOR = a[i], maskAND = a[i];
    int min_j = i + 1;

    while(cur > 0) {
      int nxt = 0;
      for(int j = 0; j < B; j++) {
        if(!bset(maskOR, j)) cmax(nxt, prev[cur][1][j]);
        if(bset(maskAND, j)) cmax(nxt, prev[cur][0][j]);
      }
      // between nxt+1 and cur the maskOR and maskAND will be the same
      cmin(min_j, query(nxt + 1, cur, maskOR - maskAND - min_cost));

      // printf("i=%d cur=%d nxt=%d OR=%d AND=%d\n", i, cur, nxt, maskOR, maskAND);

      for(int j = 0; j < B; j++) {
        if(prev[cur][1][j] == nxt) maskOR |= (1 << j);
        if(prev[cur][0][j] == nxt) maskAND &= ~(1 << j);
      }
      cur = nxt;
    }

    // DBG(min_j);
    for(int k = min_j; k <= i; k++) 
      cmax(ans[k], i - min_j + 1);
    // puts("");
  }

  for(int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i==n]);

  return 0;
}