#include <cmath>
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 200005;

long long n, cnt, tot, a[N], s[N];
long long answer, b[N], c[N];

int rt, x, y, z, topL, topR, bin[N], stL[N], stR[N];

double kL[N], kR[N];
vector <int> pop[N];

struct Node
{
    int l, r, dat, num, siz;
    long long val, sum, o;
    double k;
};
Node t[N << 1];

long long New(int num, long long val, long long o, double k)
{
    long long pos;
    if(cnt)
        pos = bin[cnt --];
    else
        pos = ++tot;
    t[pos] = {0, 0, rand(), num, num, val, val, o, k};
    return pos;
}

void push_up(long long p)
{
    t[p].siz = t[t[p].l].siz + t[t[p].r].siz + t[p].num;
    t[p].sum = t[t[p].l].sum + t[t[p].r].sum + t[p].val;
}

long long merge(long long x, long long y)
{
    if(!x || !y)
        return x + y;
    if(t[x].dat > t[y].dat)
    {
        t[x].r = merge(t[x].r, y);
        push_up(x);
        return x;
    }
    else
    {
        t[y].l = merge(x, t[y].l);
        push_up(y);
        return y;
    }
}

void split(long long p, int &x, int &y, double k, bool o = 0)
{
    if(!p)
    {
        x = y = 0;
        return;
    }
    if((!o && t[p].k > k) || (o && t[p].k >= k))
    {
        y = p;
        split(t[p].l, x, t[p].l, k, o);
    }
    else
    {
        x = p;
        split(t[p].r, t[p].r, y, k, o);
    }
    push_up(p);
}

double get(long long x, long long y)
{
    return 1.0 * (s[x] - s[y]) / (x - y);
}

long long ins(double k, long long p)
{
    split(rt, x, y, k);
    long long s = t[y].siz;
    answer += t[x].sum * t[p].siz;
    rt = merge(x, merge(p, y));
    return s;
}

long long del(double k, long long o)
{
    long long s;
    split(rt, x, y, k);
    split(x, x, z, k, 1);
    if(!t[z].l && !t[z].r)
    {
        bin[++cnt] = z;
        answer -= t[x].sum * t[z].siz;
        s = t[y].siz;
        rt = merge(x, y);
    }
    else
    {
        long long u = z, v = (t[z].l ? t[z].l : t[z].r);
        if(t[u].o == o)
        {
            bin[++cnt] = u;
            if(t[z].l)
            {
                answer -= (t[x].sum + t[v].sum) * t[u].num;
                s = t[y].siz;
            }
            else
            {
                answer -= t[x].sum * t[u].num;
                s = t[y].siz + t[v].siz;
            }
            rt = merge(x, merge(v, y));
        }
        else
        {
            bin[++cnt] = v;
            t[u].l = t[u].r = 0;
            t[u].siz = t[u].num;
            t[u].sum = t[u].val;
            if(t[z].l)
            {
                answer -= t[x].sum * t[v].num;
                s = t[y].siz + t[u].siz;
            }
            else
            {
                answer -= (t[x].sum + t[u].sum) * t[v].num;
                s = t[y].siz;
            }
            rt = merge(x, merge(u, y));
        }
    }
    return s;
}

signed main()
{
    scanf("%lld", &n);
    for(long long i = 1; i <= n; ++ i)
    {
        scanf("%lld", &a[i]);
        s[i] = s[i - 1] + a[i];
        b[i] = b[i - 1] + a[i] * i;
        c[i] = c[i - 1] + a[i] * (n - i + 1);
    }

    for(long long i = n; i >= 1; -- i)
    {
        stR[++topR] = i;
        while(topR > 2 && get(stR[topR], stR[topR - 2]) <= get(stR[topR], stR[topR - 1]))
            pop[i].push_back(stR[topR - 1]), stR[topR - 1] = stR[topR], -- topR;
    }

    for(long long i = 2; i <= topR; ++ i)
    {
        long long l = stR[i], r = stR[i - 1];
        kR[r] = abs(get(l, r));
        long long pos = ins(kR[r], New(r - l, s[r] - s[l], 1, kR[r]));
        answer += (c[r] - c[l]) + (s[r] - s[l]) * (pos + 1 - (n - r + 1));
    }

    printf("%lld ", answer + a[1] * n - a[1]);

    stL[++topL] = 1;
    for(long long i = 2, pos, l, r; i <= n; ++ i)
    {
        stL[++topL] = i;
        while(topL > 2 && 1.0 * (s[i] - s[stL[topL - 2] - 1] - a[i]) / (stL[topL - 2] - i) >= 1.0 * (s[i] - s[stL[topL - 1] - 1] - a[i]) / (stL[topL - 1] - i))
        {
            l = stL[topL - 2];
            r = stL[topL - 1];
            pos = del(kL[stL[topL - 2]], 0);
            answer -= (b[r - 1] - b[l - 1]) + (s[r - 1] - s[l - 1]) * (pos + 1 - l); 
            stL[-- topL] = i;
        }
        kL[stL[topL - 1]] = abs(1.0 * (s[i] - s[stL[topL - 1] - 1] - a[i]) / (stL[topL - 1] - i));
        pos = ins(kL[stL[topL - 1]], New(i - stL[topL - 1], s[i - 1] - s[stL[topL - 1] - 1], 0, kL[stL[topL - 1]]));
        answer += (b[i - 1] - b[stL[topL - 1] - 1]) + (s[i - 1] - s[stL[topL - 1] - 1]) * (pos + 1 - stL[topL - 1]);

        long long u = stR[topR --];
        if(!topR)
            continue;

        pos = del(kR[stR[topR]], 1);
        answer -= (c[stR[topR]] - c[u]) + (s[stR[topR]] - s[u]) * (pos + 1 - (n - stR[topR] + 1));
        
        if(!pop[u].size() && stR[topR] != i)
        {
            r = stR[topR];
            kR[r] = abs(get(r, i));
            pos = ins(kR[r], New(r - i, s[r] - s[i], 1, kR[r]));
            answer += (c[r] - c[i]) + (s[r] - s[i]) * (pos + 1 - (n - r + 1));
            stR[++topR] = i;
        }
        for(long long j = (long long)pop[u].size() - 1; j >= 0; -- j)
        {
            l = pop[u][j]; 
            r = stR[topR];
            kR[r] = abs(get(l, r));
            pos = ins(kR[r], New(r - l, s[r] - s[l], 1, kR[r]));
            answer += (c[r] - c[l]) + (s[r] - s[l]) * (pos + 1 - (n - r + 1));
            stR[++topR] = pop[u][j];
        }

        printf("%lld ", answer + a[i] * n - a[i]);
    }

    return 0;
}
/*
10
18 37 81 6 58 99 87 34 75 
*/