#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

template<typename T>
using ordered_set = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#include "grader.h"

// #define int long long

struct Nd{
	int64_t a1,d1,a2,d2;
	int l,r;
};

struct ST{
	int n,s;
	int root;
	Nd*v=new Nd[1000000];
	
	ST(int n):n(n),root(0),s(0){
	}
	
	void update1(int&i,int l,int r,int ll,int rr){
		if(l>rr||r<ll){
			return;
		}
		if(!i){
			i=++s;
			v[i]={};
		}
		if(l>=ll&&r<=rr){
			v[i].a1+=l-ll;
			v[i].d1+=1;
			return;
		}
		update1(v[i].l,l,(l+r)/2,ll,rr);
		update1(v[i].r,(l+r)/2+1,r,ll,rr);
	}
	
	void update1(int ll,int rr){
		update1(root,0,n-1,ll,rr);
	}
	
	void update2(int&i,int l,int r,int ll,int rr){
		if(l>rr||r<ll){
			return;
		}
		if(!i){
			i=++s;
			v[i]={};
		}
		if(l>=ll&&r<=rr){
			v[i].a2+=rr-r;
			v[i].d2+=1;
			return;
		}
		update2(v[i].l,l,(l+r)/2,ll,rr);
		update2(v[i].r,(l+r)/2+1,r,ll,rr);
	}
	
	void update2(int ll,int rr){
		update2(root,0,n-1,ll,rr);
	}
	
	int64_t query(int&i,int l,int r,int ii){
		if(!i||l>ii||r<ii){
			return 0;
		}
		int64_t ans=v[i].a1+v[i].d1*(ii-l)+v[i].a2+v[i].d2*(r-ii);
		if(l==r){
			return ans;
		}
		if(ii<=(l+r)/2){
			ans+=query(v[i].l,l,(l+r)/2,ii);
		}
		else{
			ans+=query(v[i].r,(l+r)/2+1,r,ii);
		}
		return ans;
	}
	
	int64_t query(int ii){
		return query(root,0,n-1,ii);
	}
};

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int N=getN(),K=getK(),M=4e8;
	ordered_set<int>s;
	ST a(M+1);
	auto calc=[&](int x)->int64_t{
		return a.query(x);
	};
	for(int i=0;i<N;i++){
		int y=Data();
		s.insert(y);
		a.update1(y+K,M);
		a.update2(0,y);
		int64_t ans=1e18;
		{
			int l=0,h=i;
			while(l<h){
				int m=(l+h)/2;
				if(m>=i-s.order_of_key(*s.find_by_order(m)+K)){
					h=m;
				}
				else{
					l=m+1;
				}
			}
			ans=min(ans,calc(*s.find_by_order(h)));
			if(h>0)ans=min(ans,calc(*s.find_by_order(h-1)));
		}
		{
			int l=0,h=i;
			while(l<h){
				int m=(l+h)/2;
				if(s.order_of_key(*s.find_by_order(m)-K)>=i-m){
					h=m;
				}
				else{
					l=m+1;
				}
			}
			ans=min(ans,calc(*s.find_by_order(h)-K));
			if(h>0)ans=min(ans,calc(*s.find_by_order(h-1)-K));
		}
		Solution(ans);
	}
	return 0;
}