#include <bits/stdc++.h>
using namespace std;
#define int              long long int
#define double           long double
#define print(a)         for(auto x : a) cout << x << " "; cout << endl
inline int power(int a, int b) {
    int x = 1;
    while (b) {
        if (b & 1) x *= a;
        a *= a;
        b >>= 1;
    }
    return x;
}


const int M = 1000000007;
const int N = 3e5+9;
const int INF = 2e9+1;
const int LINF = 2000000000000000001;

//_ ***************************** START Below *******************************



typedef pair<int,int> pii;

vector<int> a;


void rebalance(set<pii, greater<pii>>& leftMax, set<pii>& rightMin, int& leftSum, int& rightSum){
	
	if(leftMax.size() > rightMin.size()){
		auto left = *leftMax.begin();
		leftMax.erase(left);
		
		leftSum -= left.first;
		rightSum += left.first;
		
		rightMin.insert(left);
	}
	else if(rightMin.size() > leftMax.size()+1){
		auto right = *rightMin.begin();
		rightMin.erase(right);
		
		rightSum -= right.first;
		leftSum += right.first;
		
		leftMax.insert(right);
	}
	
	if(!leftMax.empty() && !rightMin.empty() && leftMax.begin()->first > rightMin.begin()->first ){
		auto left = *leftMax.begin(); 
		auto right = *rightMin.begin();
		
		
		leftMax.erase(left);
		rightMin.erase(right);
		
		leftSum -= left.first;
		rightSum -= right.first;
		
		leftMax.insert(right);
		leftSum += right.first;
		
		rightMin.insert(left);
		rightSum += left.first;
	}
	
}

vector<int> consistency(int n, int k) {
	
	vector<int> ans;
	
	set<pii> rightMin;
	int rightSum = 0;
	
	set<pii, greater<pii> > leftMax;
	int leftSum = 0;
	
	int s = 0, e = 0;
	while(e<n){
		leftSum += a[e];
		leftMax.insert({a[e], e});
		rebalance(leftMax, rightMin, leftSum, rightSum);
		
		if(e-s+1 < k){
			e++;
		}
		else{
			auto left = *leftMax.begin();
			auto right = *rightMin.begin();
			
			int x = left.first;
			int y = right.first;
			
			int m = y;
			if( !(k&1) ) m = (x+y)/2;
			
			int cost = (k/2) * m - leftSum;
			cost +=  rightSum - ((k+1)/2) * m;
			
			ans.push_back(cost);
			
			if(leftMax.count({a[s], s})){
				leftMax.erase({a[s], s});
				leftSum -= a[s];
			}
			else{
				rightMin.erase({a[s], s});
				rightSum -= a[s];
			}
			rebalance(leftMax, rightMin, leftSum, rightSum);
			
			s++;
			e++;
		}
	}
	
	return ans;

}



















// typedef pair<int,int> pii;

vector<int> practice(int n, int k) {
	
	
}








void solve() {
    
    int n, k;
    cin>>n >> k;
	
	a.resize(n);
    for(int i=0; i<n; i++) cin >> a[i];
    
    auto ans1 = consistency(n, k);
    for(auto& it : ans1 )	cout << it << " "; cout << endl;
    
    
	// auto p = practice(n, k);
	// for(auto& t : p) cout << t << " "; cout << endl;
    


}





int32_t main() {
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int t = 1;
    while (t--) {
        solve();
    }

    return 0;
}