#pragma GCC optimize("Ofast")
#pragma GCC optimize("O2")
#include<bits/stdc++.h>
bool Mbg;
using namespace std;
/*--------------------------------------------------------------------------------------*/
#define cin cio
#define cout cio
#define Fs 100000
#define inline __inline__ __attribute__((always_inline))
#define iopt inline IO& operator
#define Tc()(_A==_B&&(_B=(_A=Fi)+fread(Fi,1,100000,stdin),_A==_B)?EOF:*_A++)
#define Pc(Ch)(FS<Fs?Fo[FS++]=Ch:(fwrite(Fo,1,Fs,stdout),Fo[(FS=0)++]=Ch))
int Tp,FS;char Ch,*_A,*_B,Fi[Fs],Fo[Fs],Sk[Fs];
struct IO{
	template<typename T>
	iopt>>(T&x){x=0;while(!isdigit(Ch=Tc()));while(x=10*x +(Ch&15),isdigit(Ch=Tc()));return*this;}
	iopt>>(char*x){int I=0;for(;((x[I]=Tc())!=' ')&&(x[I]!='\n');++I);x[I]='\0';return*this;}
	iopt>>(char&x){x=Tc();return*this;}
	template<typename T>
	iopt<<(T x){if(!x){return Pc('0'),*this;}if(x<0)Pc('-'),x=-x;while(x)Sk[++Tp]=x%10+48,x/=10;while(Tp)Pc(Sk[Tp--]);return*this;}
	iopt<<(const char*x){for(;*x!='\0';Pc(*(x++)));return*this;}
	iopt<<(char x){Pc(x);return*this;};~IO(){fwrite(Fo,1,FS,stdout),FS=0;}void tie(int){}
}cio;/*----------------------------------------------------------------------------------*/
#define vec vector
#define pb push_back
#define eb emplace_back
#define siz(vec) (int)((vec).size())
#define all(vec) (vec).begin(),(vec).end()
template<class T>
void operator +=(vec<T> &lhs,const T &rhs){lhs.push_back(rhs);}
#define pii pair<int,int>
#define x first
#define y second
#define mp make_pair
#define exc(expr) if(expr)continue;
#define stop(expr) if(expr)break;
#define ret(expr) if(expr)return;
#define deb(var) cerr<<#var<<'='<<(var)<<"; "
#define debl(var) cerr<<#var<<'='<<(var)<<";\n"
#define ins insert
#define era erase
#define lb lower_bound
#define ub upper_bound
#define ll long long
#define inf (long long)(1e9)
template<class T>
bool Min(T &x,const T &y){return x>y?x=y,1:0;}
template<class T>
bool Max(T &x,const T &y){return x<y?x=y,1:0;}
const int mod=998244353;
void Add(int &x,const int &y){x=x+y<mod?x+y:x+y-mod;}
void Dec(int &x,const int &y){x=x>=y?x-y:x-y+mod;}
int fpm(int x,int y){
    int ans=1;for(;y;y>>=1,x=1ll*x*x%mod)if(y&1)ans=1ll*x*ans%mod;return ans;
}

int n,m,a[50010],f[50010];

const int N=20000000;
int tot,ls[N],rs[N];
int sum[N],siz[N];
void pu(int u){
    siz[u]=siz[ls[u]]+siz[rs[u]];
    sum[u]=sum[ls[u]]+sum[rs[u]];
}
pii split(int u,int l,int r,int k){ //[1,k],[k+1,n]
    if(!u)return {0,0};
    if(r<=k)return {u,0};
    if(l>k)return {0,u};
    int mid=(l+r)>>1;
    if(k<=mid){
        auto sp=split(ls[u],l,mid,k);
        ls[++tot]=sp.x;
        ls[u]=sp.y;
        pu(tot),pu(u);
        return {tot,u};
    }else{
        auto sp=split(rs[u],mid+1,r,k);
        rs[++tot]=sp.y;
        rs[u]=sp.x;
        pu(tot),pu(u);
        return {u,tot};
    }
}
int merge(int u,int v,int l,int r){
    if(!siz[u])u=0;
    if(!siz[v])v=0;
    if(!u||!v)return u|v;
    int mid=(l+r)>>1;
    ls[u]=merge(ls[u],ls[v],l,mid);
    rs[u]=merge(rs[u],rs[v],mid+1,r);
    return pu(u),u;
}
void ins(int &u,int l,int r,int x){
    if(!u)u=++tot;
    if(l==r){
        ++siz[u];
        sum[u]+=x;
        return;
    }
    int mid=(l+r)>>1;
    x<=mid?
    ins(ls[u],l,mid,x):
    ins(rs[u],mid+1,r,x);
    pu(u);
}
int find(vec<int> rts,int l,int r,int &k){
    if(!k)return l-1;
    int s=0;
    for(auto x:rts){
        s+=siz[x];
    }
    if(s<=k){
        k-=s;
        return r;
    }
    if(l==r){
        for(auto x:rts)
            k-=siz[x];
        return l;
    }
    int mid=(l+r)>>1,lsz=0;
    for(auto x:rts){
        lsz+=siz[ls[x]];
    }

    if(k<=lsz){
        for(auto &x:rts){
            x=ls[x];
        }
        return find(rts,l,mid,k);
    }else{
        for(auto &x:rts){
            x=rs[x];
        }
        k-=lsz;
        return find(rts,mid+1,r,k);
    }
}
struct Ds{
    int rt;
    void clear(){
        rt=0;
    }
    void Ins(int x){
        ins(rt,1,n,x);
    }
    void join(Ds &rhs){
        rt=merge(rt,rhs.rt,1,n);
        rhs.rt=0;
    }
    void sjoin(Ds &rhs,int k){
        int x,y;
        tie(x,y)=split(rhs.rt,1,n,k);
        rhs.rt=y;
        rt=merge(rt,x,1,n);
    }
}ds[68][68];

// void dfs(int &u,int l,int r){
//     ret(!u||!siz[u]);
//     if(l==r){
//         siz[u]=sum[u]=0;
//         ds[a[l]][0].Ins(l);
//         return;
//     }
//     int mid=(l+r)>>1;
//     dfs(ls[u],l,mid);
//     dfs(rs[u],mid+1,r);
//     u=0;
// }
int ans[50010];
void getans(int u,int l,int r,int a){
    ret(!u||!siz[u]);
    if(l==r){
        ans[l]=a;
    }else{
        int mid=(l+r)>>1;
        getans(ls[u],l,mid,a);
        getans(rs[u],mid+1,r,a);
    }
}

void work(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    if(n==1){
        cout<<m<<'\n';return;
    }

    f[n]=m;

    ds[a[n]][min(m,65)].Ins(n);

    int j=n;
    for(int i=n-1;i;i--){
        int L=(n-i)/2,S=0;
        L=max(0,L-(j-i-1));
        for(int y=1;y<=64;y++){
            for(int x=1;x<=y;x++){
                int t=min(L,siz[ds[x][y-x].rt]);
                S+=t*y;
                L-=t;
            }
        }
        if(S>m){
            f[i]=-1;
            // ds[0][0].Ins(i);
            continue;
        }

        f[i]=m-S;

        // deb(i),debl(f[i]);
        for(int x=1;x<=64;x++){
            for(int y=64;~y;y--){
                ds[x][min(65,y+x)].join(ds[x][y]);
            }
        }

        L=(n-i+1)/2;
        for(int x=65;x;x--){
            vec<int> rts;
            for(int y=1;y<=64;y++){
                if(ds[y][x].rt)rts+=ds[y][x].rt;
            }
            int M=find(rts,1,n,L);
            for(int y=1;y<=64;y++){
                ds[y][0].sjoin(ds[y][x],M);
            }
        }

        {// 处理 ds[0][0]
            while(j>i+1){
                --j;
                ds[a[j]][0].Ins(j);
            }
            --j;
            // dfs(ds[0][0].rt,1,n);
        }

        ds[a[i]][min(f[i],65)].Ins(i);
    }


    for(int x=1;x<=64;x++){
        for(int y=0;y<=64;y++){
            getans(ds[x][y].rt,1,n,y);
        }
    }

    int x=1;
    while(x<=n&&f[x]==-1){
        ans[x++]=-1;
    }

    if(x<=n){
        ans[x]=f[x];
    }

    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" \n"[i==n];
    }

    // debl(tot);
}
bool Med;
signed main(){
    ios::sync_with_stdio(0),
    cin.tie(0),cout.tie(0);
    int T=1;while(T--)work();
    // cerr<<"Time: "<<clock()<<" ms;\n";
    // cerr<<"Memory: "<<abs(&Med-&Mbg)/1024.0/1024.0<<" MiB.\n";
}
/*
- CONTINUE, NON-STOPPING, FOR THE FAITH
- START TYPING IF YOU DON'T KNOW WHAT TO DO
- STOP TYPING IF YOU DON'T KNOW WHAT YOU'RE DOING
*/