#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;

set<pii, greater<pii> > leftMax;
set<pii> rightMin;

void rebalance(int& leftSum, int& rightSum){

    if(!leftMax.empty() && !rightMin.empty() && (*rightMin.begin()).first < (*leftMax.begin()).first ){
        auto leftTop = *leftMax.begin();
        auto rightTop = *rightMin.begin();

        leftMax.erase(leftTop);
        rightMin.erase(rightTop);

        leftSum -= leftTop.first;
        leftSum += rightTop.first;

        rightSum -= rightTop.first;
        rightSum += leftTop.first;

        leftMax.insert(rightTop);
        rightMin.insert(leftTop);
    }

    if(leftMax.size() > rightMin.size()){
        auto leftTop = *leftMax.begin();
        leftMax.erase(leftTop);
        rightMin.insert(leftTop);

        leftSum -= leftTop.first;
        rightSum += leftTop.first;
    }
    else if(rightMin.size() > leftMax.size()+1 ){
        auto rightTop = *rightMin.begin();
        rightMin.erase(rightTop);
        leftMax.insert(rightTop);

        rightSum -= rightTop.first;
        leftSum += rightTop.first;
    }
}


vector<int> consistency1(int n, int k) {
    vector<int> ans;

    int leftSum = 0;
    int rightSum = 0;

    int s = 0, e = 0;
    while(e < n){
        leftMax.insert({a[e], e});
        leftSum += a[e];
        rebalance(leftSum, rightSum);


        if(e - s + 1 < k){
            e++;
        }
        else{
            auto rightTop = *rightMin.begin();
            int median = rightTop.first;
            
            if( !(k & 1) ) {
                auto leftTop = *leftMax.begin();
                median = (leftTop.first + rightTop.first) / 2;
            }

            int cost = ((k / 2) * median - leftSum) + (rightSum - ((k + 1) / 2) * median);
            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(leftSum, rightSum);

            s++;
            e++;
        }
    }

    return ans;
}












void solve() {
    
    int n, k;
    cin>>n >> k;
	
	a.resize(n);
    for(int i=0; i<n; i++) cin >> a[i];
    
    auto ans1 = consistency1(n, k);
    for(auto& it : ans1 ) {
        cout << it << " ";
    }
    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;
}