#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

using u64 = unsigned long long;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

struct Treap {
    Treap *lc = nullptr, *rc = nullptr;
    int sz = 1;
    i64 k = 0, b = 0;
    i64 val = 0;
    u64 w = rng();
    Treap(i64 v) : val(v) {}
};

int size(Treap *t) {
    return t ? t->sz : 0;
}

void pull(Treap *t) {
    t->sz = size(t->lc) + size(t->rc) + 1;
}

void apply(Treap *t, i64 k, i64 b) {
    if (!t) { return; }
    t->k += k;
    t->b += b;
    t->val += k * (1 + size(t->lc)) + b;
}

void push(Treap *t) {
    apply(t->lc, t->k, t->b);
    apply(t->rc, t->k, t->k * (1 + size(t->lc)) + t->b);
    t->k = t->b = 0;
}

template <typename F>
pair<Treap*, Treap*> split(Treap *t, int s, F f) {
    if (!t) { return {t, t}; }
    push(t);
    Treap *a, *b;
    if (f(t, s + size(t->lc) + 1)) {
        b = t;
        tie(a, b->lc) = split(t->lc, s, f);
    } else {
        a = t;
        tie(a->rc, b) = split(t->rc, s + size(t->lc) + 1, f);
    }
    pull(t);
    return {a, b};
}

Treap* merge(Treap *a, Treap *b) {
    if (!a) { return b; }
    if (!b) { return a; }
    push(a), push(b);
    if (a->w > b->w) {
        a->rc = merge(a->rc, b);
        pull(a);
        return a;
    } else {
        b->lc = merge(a, b->lc);
        pull(b);
        return b;
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    cin >> t;

    auto solve = [&]() {
        int n;
        cin >> n;

        vector<int> p(n);
        for (int i = 0; i < n; i++) {
            cin >> p[i];
        }

        int a, b;
        cin >> a >> b;

        vector<i64> func(n + 1);
        for (int i = 1; i <= n; i++) {
            func[i] = 1LL * i * i + a * i + b;
        }

        Treap *t = nullptr;

        for (int i = 0; i < n; i++) {
            auto [t1, t2] = split(t, 0, [&](Treap *t, int s) {
                return func[s] * p[i] >= t->val;
            });
            int s = size(t1) + 1;
            apply(t2, 2 * p[i], (2 * s + a - 1) * p[i]);
            t = merge(merge(t1, new Treap (func[s] * p[i])), t2);
        }

        i64 ans = 0;

        for (int i = 1; i <= n; i++) {
            auto [t1, t2] = split(t, 0, [&](Treap *t, int s) {
                return s > 1;
            });
            ans += t1->val;
            t = t2;
            cout << ans << " \n"[i == n];
        }
    };

    while (t--) {
        solve();
    }
    
    return 0;
}