//首先是从贪心的角度解决了，只要能把能量可以遍历到的区间放在最前面，那就可以产生
//字典序最大。在由于能量是变化的，所以区间查询也是动态的。
//并且某个元素放置完之后，还得在区间内删除，防止被重复选择，所以要单点修改。

实现的时候注意这是严格最大值。要去除重复元素，本来想用unique，但是存的是pii，所以只能手动查找了。

#include<bits/stdc++.h>
//首先是从贪心的角度解决了，只要能把能量可以遍历到的区间放在最前面，那就可以产生
//字典序最大。在由于能量是变化的，所以区间查询也是动态的。
//并且某个元素放置完之后，还得在区间内删除，防止被重复选择，所以要单点修改。

using namespace std;
using ll =long long;
using pii = pair<int,int>;
const int N = 1e5+3;
int a[N];
int n,k;
struct Node{
    int l,r;
    int v,nv;
    int vi,nvi;
    //注意这里的次大值，是严格次大值。
}tr[N*4];

void push_up(Node &u,Node &l,Node &r){
    //重新封装一下push_up有利于合并
    pii temp[4]={
        {l.v,l.vi},
        {l.nv,l.nvi},
        {r.v,r.vi},
        {r.nv,r.nvi}};
    sort(temp,temp+4,[&](pii a,pii b){
        if(a.first==b.first)
            //消耗的能量少
            return a.second<b.second;
        return a.first>b.first;
    });
    int size_=1;
    u.v=temp[0].first,u.vi=temp[0].second;
    u.nv=0,u.nvi=0;
    for(int i=0;i<3;i++){
        if(temp[i].first!=temp[i+1].first){
            u.nv=temp[i+1].first,u.nvi=temp[i+1].second;
            break;
        }
    }
}

void push_up(int u){
    push_up(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r){
    tr[u]={l,r};
    if(l==r){
        tr[u].v=a[l],tr[u].vi=l;
        return ;
    }
    int mid=(l+r)/2;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    push_up(u);
}
Node query(int u,int ql,int qr){
    int l=tr[u].l,r=tr[u].r;
    if(l>=ql&&r<=qr)return tr[u];
    int mid = (l+r)/2;
    Node res={0,0,0,0,0,0};
    if(ql<=mid)res=query(u<<1,ql,qr);
    if(qr>mid){
        Node t=query(u<<1|1,ql,qr);
        push_up(res,res,t);
    }
    return res;
}
void modify(int u,int x){
    int l=tr[u].l,r=tr[u].r;
    if(tr[u].l==x&&tr[u].r==x){
        Node temp={x,x,0,0,0,0};
        tr[u]=temp;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid)modify(u<<1,x);
    if(x>mid)modify(u<<1|1,x);
    push_up(u);
}
int ans[N];
int main(){
    memset(ans,-1,sizeof ans);
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    build(1,1,n);
    for(int i=1;i<=n;i++){
        int r=i+k;
        Node q_n=query(1,i,r);
        if(q_n.v==0)continue;
        if(q_n.v!=ans[i-1]){
            ans[i]=q_n.v;
            modify(1,q_n.vi);
            k-=(q_n.vi-i);
        }
        if(q_n.v==ans[i-1]&&q_n.nv!=0){
            ans[i]=q_n.nv;
            modify(1,q_n.nvi);
            k-=(q_n.nvi-i);
        }
    }

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