#!/bin/python3

class maxer: 
    def __init__(self,m,A):
        self.m = m
        n=1
        while n<m:
            n*=2
        self.n = n
        self.data = [0]*(2*n)
        for i in range(m):
            self.data[i+n] = A[i]
        for i in reversed(range(1,n)):
            self.data[i] = max(self.data[2*i],self.data[2*i+1])
    def qmax(self,l,r):
        maxi = 0
        l+=self.n
        r+=self.n
        while l<r:
            if (l%2)==1:
                maxi = max(maxi,self.data[l])
                l+=1
            if (r%2)==1:
                r-=1
                maxi = max(maxi,self.data[r])
            l //=2
            r //=2
        return maxi
class miner: 
    def __init__(self,m,A):
        self.m = m
        n=1
        while n<m:
            n*=2
        self.n = n
        self.data = [10**9]*(2*n)
        for i in range(m):
            self.data[i+n] = A[i]
        for i in reversed(range(1,n)):
            self.data[i] = min(self.data[2*i],self.data[2*i+1])
    def qmin(self,l,r):
        maxi = 10**9
        l+=self.n
        r+=self.n
        while l<r:
            if (l%2)==1:
                maxi = min(maxi,self.data[l])
                l+=1
            if (r%2)==1:
                r-=1
                maxi = min(maxi,self.data[r])
            l //=2
            r //=2
        return maxi
class orer: 
    def __init__(self,m,A):
        self.m = m
        n=1
        while n<m:
            n*=2
        self.n = n
        self.data = [0]*(2*n)
        for i in range(m):
            self.data[i+n] = A[i]
        for i in reversed(range(1,n)):
            self.data[i] = (self.data[2*i]|self.data[2*i+1])
    def qor(self,l,r):
        Q = 0
        l+=self.n
        r+=self.n
        while l<r:
            if (l%2)==1:
                Q = Q|self.data[l]
                l+=1
            if (r%2)==1:
                r-=1
                Q = Q|self.data[r]
            l //=2
            r //=2
        return Q        
class ander: 
    def __init__(self,m,A):
        self.m = m
        n=1
        while n<m:
            n*=2
        self.n = n
        self.data = [A[-1]]*(2*n)
        for i in range(m):
            self.data[i+n] = A[i]
        for i in reversed(range(1,n)):
            self.data[i] = (self.data[2*i]&self.data[2*i+1])
    def qand(self,l,r):
        Q = self.data[self.n+l]
        l+=self.n
        r+=self.n
        while l<r:
            if (l%2)==1:
                Q = Q&self.data[l]
                l+=1
            if (r%2)==1:
                r-=1
                Q = Q&self.data[r]
            l //=2
            r //=2
        return Q        

class fenwick: 
    def __init__(self,m):
        self.m = m
        n=1
        while n<m:
            n*=2
        self.n = n
        self.data = [-1]*(n+m)
    def add(self,l,r,val):
        l+=self.n
        r+=self.n
        while l<r:
            if (l%2)==1:
                self.data[l] = max(val,self.data[l])
                l+=1
            if (r%2)==1:
                r-=1
                self.data[r] = max(val,self.data[r])
            l //=2
            r //=2
    def summa(self,ind):
        ind += self.n
        maxi = -1
        while ind>0:
            maxi = max(self.data[ind],maxi)
            ind//=2
        return maxi
import sys

n,k = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
MAX = maxer(len(A),A)
MIN = miner(len(A),A)
OR  =  orer(len(A),A)
AND = ander(len(A),A)
longest = fenwick(len(A))

if n < 1000:
    for l in range(n):
        a = A[l]
        b = A[l]
        c = A[l]
        d = A[l]
        best = (0,0,0)
        if a-b+c-d>=k:
            best = max(best,(1,l,l+1))
        for r in range(l+1,n):
            #print(l,r)
            a = a|A[r]
            b = max(b,A[r])
            c = min(c,A[r])
            d = d&A[r]
            #print(OR.qor(l,r+1),MAX.qmax(l,r+1), MIN.qmin(l,r+1), AND.qand(l,r+1))
            if a-b+c-d>=k:
                best = max(best,(r-l+1,l,r))
        if best[0]!=0:
            longest.add(best[1],best[2]+1,best[0])
                #print("found",l,r)
                #for i in range(n):
                #    print(longest.summa(i),end = ' ')
                #print()
    for i in range(n):
        print(longest.summa(i))
    sys.exit()



for l in range(n):
    a = l
    b = n
    while b-a>1:
        m = (a+b)//2
        
        if OR.qor(l,m+1)-MAX.qmax(l,m+1)+MIN.qmin(l,m+1)-AND.qand(l,m+1)>=k:
            a = m
        else:
            b = m
    if a==l:
        if OR.qor(l,a+1)-MAX.qmax(l,a+1)+MIN.qmin(l,a+1)-AND.qand(l,a+1)>=k:
            longest.add(l,l+1,1)
    else:
        longest.add(l,a+1,a-l+1)
    

    a = A[l]
    b = A[l]
    c = A[l]
    d = A[l]
    best = (0,0,0)
    if a-b+c-d>=k:
        best = max(best,(1,l,l+1))
    for r in range(l+1,min(l+50,n)):
            #print(l,r)
        a = a|A[r]
        b = max(b,A[r])
        c = min(c,A[r])
        d = d&A[r]
            #print(OR.qor(l,r+1),MAX.qmax(l,r+1), MIN.qmin(l,r+1), AND.qand(l,r+1))
        if a-b+c-d>=k:
            best = max(best,(r-l+1,l,r))
    if best[0]!=0:
        longest.add(best[1],best[2]+1,best[0])
                #print("found",l,r)
                #for i in range(n):
                #    print(longest.summa(i),end = ' ')
                #print()
#    a = A[l]
#    b = A[l]
#    c = A[l]
#    d = A[l]
#    best = (0,0,0)
#    if a-b+c-d>=k:
#        best = max(best,(1,l,l+1))
#    for r in range(l+1,n):
#        #print(l,r)
#        a = a|A[r]
#        b = max(b,A[r])
#        c = min(c,A[r])
#        d = d&A[r]
        #print(OR.qor(l,r+1),MAX.qmax(l,r+1), MIN.qmin(l,r+1), AND.qand(l,r+1))
#        if a-b+c-d>=k:
#            best = max(best,(r-l+1,l,r))
#    if best[0]!=0:
#        longest.add(best[1],best[2]+1,best[0])
            #print("found",l,r)
            #for i in range(n):
            #    print(longest.summa(i),end = ' ')
            #print()

for i in range(n):
    print(longest.summa(i))