#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> PP;
// #define MOD 1000000007
#define MOD 998244353
#define INF 2305843009213693951
#define PI 3.141592653589
#define setdouble setprecision
#define REP(i,n) for(ll i=0;i<(n);++i)
#define OREP(i,n) for(ll i=1;i<=(n);++i)
#define RREP(i,n) for(ll i=(n)-1;i>=0;--i)
#define ORREP(i,n) for(ll i=(n);i>=1;--i)
#define rep(i,a,b) for(ll i=(a);i<=(b);++i)
#define ALL(v) (v).begin(), (v).end()
#define chmin(k,m) k = min(k,m)
#define chmax(k,m) k = max(k,m)
#define GOODBYE do { cout << "-1" << endl; return 0; } while (false)
#define MM <<" "<<
#define Endl endl

class compress{
    // Copyright (c) 2023 0214sh7
    // https://github.com/0214sh7/library/
    private:
    std::vector<int> E;
    
    public:
    void init(std::vector<long long> A){
        E.clear();
        sort(A.begin(),A.end());
        for(int i=0;i<A.size();i++){
            if(i==0 || A[i]!=A[i-1]){
                E.push_back(A[i]);
            }
        }
    }
    
    compress(std::vector<long long> A){
        init(A);
    }
    
    int size(){
        return (int)E.size();
    }
    
    int value(int x){
        if(0<=x && x<(int)E.size()){
            return E[x];
        }else{
            return 0;
        }
    }
    
    int index(int X){
        return (upper_bound(E.begin(),E.end(),X))-E.begin()-1;
    }
    
};

template<typename T,typename F>
class lazysegmenttree{
    /*
    Copyright (c) 2024 0214sh7
    https://github.com/0214sh7/library/
    */
    //private:
    public:
    int n,height;
    
    std::vector<T> dat;
    std::vector<F> lazy;
    std::vector<bool> lazy_flag;
    std::function<T(T,T)> calc;
    T identity;
    std::function<T(F,T)> action;
    std::function<F(F,F)> composition;
    F action_identity;
    
    void eval(int k){
        if(!lazy_flag[k])return;
        if(k<n-1){
            lazy[2*k+1] = composition(lazy[k],lazy[2*k+1]);
            lazy[2*k+2] = composition(lazy[k],lazy[2*k+2]);
            lazy_flag[2*k+1] = true;
            lazy_flag[2*k+2] = true;
        }
        dat[k] = action(lazy[k],dat[k]);
        lazy[k] = action_identity;
        lazy_flag[k] = false;
    }
    
    public:
    
    void init(int N,std::function<T(T,T)> func,T Identity,
    std::function<T(F,T)> Action,std::function<F(F,F)> Composition, F Action_identity){
        n=1;height=1;
        while(n<N){n*=2;height++;};
        dat.resize(2*n-1);
        lazy.resize(2*n-1);
        lazy_flag.resize(2*n-1);
        for(int i=0;i<2*n-1;++i){
            dat[i]=Identity;
            lazy[i]=Action_identity;
            lazy_flag[i]=false;
        }
        calc = func;
        identity = Identity;
        action = Action;
        composition = Composition;
        action_identity = Action_identity;
    }
    
    lazysegmenttree(int N,std::function<T(T,T)> func,T Identity,
    std::function<T(F,T)> Action,std::function<F(F,F)> Composition,F Action_identity){
        init(N,func,Identity,Action,Composition,Action_identity);
    }
    
    void set(std::vector<T> A){
        if(n<(int)A.size()){
            n=1;height=1;
            while(n<(int)A.size()){n*=2;height++;};
            dat.resize(2*n-1);
            lazy.resize(2*n-1);
            lazy_flag.resize(2*n-1);
        }
        for(int i=0;i<2*n-1;++i){
            dat[i]=identity;
            lazy[i]=action_identity;
            lazy_flag[i]=false;
        }
        for(unsigned i=0;i<A.size();i++){
            dat[n-1+i] = A[i];
        }
        for(int i=n-2;i>=0;i--){
            dat[i] = calc(dat[2*i+1],dat[2*i+2]);
        }
    }
    
    void update(int a,int b,F f){
        a+=n-1;
        b+=n-1;
        for(int i=height-1;i>=0;i--){
            if(((a+1)>>i)>0){
                eval(((a+1)>>i)-1);
            }
            if((b>>i)>0){
                eval((b>>i)-1);
            }
        }
        
        int l = a,r = b-1;
        while(a < b){
            if(a % 2 == 0){
                lazy[a] = composition(f,lazy[a]);
                lazy_flag[a] = true;
                a++;
            }
            a = (a-1)/2;
            
            if(b % 2 == 0){
                b--;
                lazy[b] = composition(f,lazy[b]);
                lazy_flag[b] = true;
            }
            b = (b-1)/2;
        }
        
        while(l>0){
            l = (l-1)/2;
            eval(2*l+1);eval(2*l+2);
            dat[l] = calc(dat[2*l+1],dat[2*l+2]);
        }
        while(r>0){
            r = (r-1)/2;
            eval(2*r+1);eval(2*r+2);
            dat[r] = calc(dat[2*r+1],dat[2*r+2]);
        }
        
    }
    
    T query(int a,int b){
        a+=n-1;
        b+=n-1;
        for(int i=height-1;i>=0;i--){
            if(((a+1)>>i)>0){
                eval(((a+1)>>i)-1);
            }
            if((b>>i)>0){
                eval((b>>i)-1);
            }
        }
        
        T L= identity,R = identity;
        while(a < b){
            if(a % 2 == 0){
                eval(a);
                L = calc(L,dat[a]);
                a++;
            }
            a = (a-1)/2;
            if(b % 2 == 0){
                b--;
                eval(b);
                R = calc(dat[b],R);
            }
            b = (b-1)/2;
        }
        R = calc(L,R);
        return R;
    }
    
};

int main(void){
    //cin.tie(nullptr);
    //ios::sync_with_stdio(false);
    
    
    ll N;
    cin >> N;
    vector<ll> H(N);
    REP(i,N){
      cin >> H[i];
    }
    
    compress Z(H);
    
    vector<ll> Hs = H;
    sort(ALL(Hs));
    RREP(i,N-1){
      Hs[i+1]-=Hs[i];
    }
    
    // 使う和、真の和
    typedef std::pair<long long,long long> P;
    std::function<P(P,P)> func = [](P a,P b){
        return P{a.first+b.first,a.second+b.second};
    };
    
    std::function<P(long long,P)> action = [](long long f,P x){
        return P{f*x.second,x.second};
    };
    
    std::function<long long(long long,long long)> composition = [](long long f,long long g){
        return f;
    };
    
    lazysegmenttree<P,long long> SEG(N,func,{0,0},action,composition,0);
    
    vector<pair<ll,ll>> Sg(N);
    REP(i,N){
      Sg[i] = {0,Hs[i]};
    }
    SEG.set(Sg);
    
    REP(i,N){
      ll ind = Z.index(H[i]);
      SEG.update(0,ind+1,(i+1)%2);
      ll Ans = SEG.query(0,N).first;
      cout << Ans << endl;
      
      // REP(j,N){
      //   auto p = SEG.query(j,j+1);
      //   cout << p.first MM p.second << "  ";
      // }cout << endl;
    }
    
    

    return 0;
    
}