```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	var t int
	fmt.Fscan(in, &t)
	const N = 200010
	for i := 0; i < t; i++ {
		var n int
		fmt.Fscan(in, &n)
		a := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &a[i])
		}
		S := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			S[i] = S[i-1] + int64(a[i-1])
		}
		freq := NewFenwick(N)
		sumv := NewFenwick(N)
		seg := NewSegTree(N)
		ans := make([]int64, 0, n)
		for k := 1; k <= n; k++ {
			aa := a[k-1]
			if aa > 0 {
				freq.Update(aa, 1)
				sumv.Update(aa, int64(aa))
				seg.UpdateRange(1, 1, N, 1, aa, 1)
			}
			mm := seg.QueryMin(1, 1, N, 1, N)
			m := int(mm)
			r := k - m
			if r < 0 {
				r = 0
			}
			var sumExtra int64
			if r > 0 {
				low := 1
				high := N
				for low < high {
					mid := (low + high) / 2
					if freq.Query(mid) >= int64(r) {
						high = mid
					} else {
						low = mid + 1
					}
				}
				v := low
				var cc int64
				if v-1 >= 1 {
					cc = freq.Query(v-1)
				}
				var ss int64
				if v-1 >= 1 {
					ss = sumv.Query(v-1)
				}
				sumExtra = ss + (int64(r)-cc)*int64(v)
			}
			save := int64(m)*(int64(m)+1)/2 + sumExtra
			ans = append(ans, S[k]-save)
		}
		for i, v := range ans {
			if i > 0 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, v)
		}
		fmt.Fprintln(out)
	}
}

type Fenwick struct {
	data []int64
}

func NewFenwick(size int) *Fenwick {
	return &Fenwick{data: make([]int64, size+2)}
}

func (f *Fenwick) Update(idx int, val int64) {
	for idx < len(f.data) {
		f.data[idx] += val
		idx += idx & -idx
	}
}

func (f *Fenwick) Query(idx int) int64 {
	var sum int64
	for idx > 0 {
		sum += f.data[idx]
		idx -= idx & -idx
	}
	return sum
}

type SegNode struct {
	minVal, lazy int64
}

type SegTree struct {
	tree []SegNode
	size int
}

func NewSegTree(size int) *SegTree {
	t := &SegTree{
		tree: make([]SegNode, 4*(size+1)),
		size: size,
	}
	t.build(1, 1, size)
	return t
}

func (t *SegTree) build(node, start, end int) {
	if start == end {
		t.tree[node].minVal = int64(start - 1)
		return
	}
	mid := (start + end) / 2
	t.build(2*node, start, mid)
	t.build(2*node+1, mid+1, end)
	t.tree[node].minVal = tmin(t.tree[2*node].minVal, t.tree[2*node+1].minVal)
}

func tmin(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func (t *SegTree) push(node, start, end int) {
	if t.tree[node].lazy != 0 {
		t.tree[node].minVal += t.tree[node].lazy
		if start != end {
			t.tree[2*node].lazy += t.tree[node].lazy
			t.tree[2*node+1].lazy += t.tree[node].lazy
		}
		t.tree[node].lazy = 0
	}
}

func (t *SegTree) UpdateRange(node, start, end, l, r int, val int64) {
	t.push(node, start, end)
	if start > end || start > r || end < l {
		return
	}
	if l <= start && end <= r {
		t.tree[node].lazy += val
		t.push(node, start, end)
		return
	}
	mid := (start + end) / 2
	t.UpdateRange(2*node, start, mid, l, r, val)
	t.UpdateRange(2*node+1, mid+1, end, l, r, val)
	t.tree[node].minVal = tmin(t.tree[2*node].minVal, t.tree[2*node+1].minVal)
}

func (t *SegTree) QueryMin(node, start, end, l, r int) int64 {
	t.push(node, start, end)
	if start > end || start > r || end < l {
		return 1 << 60
	}
	if l <= start && end <= r {
		return t.tree[node].minVal
	}
	mid := (start + end) / 2
	left := t.QueryMin(2*node, start, mid, l, r)
	right := t.QueryMin(2*node+1, mid+1, end, l, r)
	return tmin(left, right)
}
```