```go
package main

import (
	"io"
	"os"
)

type scanner struct {
	buf  []byte
	pos  int
	read int
	in   io.Reader
}

func newScanner(in io.Reader) *scanner {
	return &scanner{
		buf: make([]byte, 1024*1024),
		in:  in,
	}
}

func (s *scanner) nextInt() int {
	for {
		if s.pos >= s.read {
			s.pos = 0
			n, err := s.in.Read(s.buf)
			if err != nil || n == 0 {
				return 0
			}
			s.read = n
		}
		if s.buf[s.pos] > 32 {
			break
		}
		s.pos++
	}
	res := 0
	for {
		if s.pos >= s.read {
			s.pos = 0
			n, err := s.in.Read(s.buf)
			if err != nil || n == 0 {
				break
			}
			s.read = n
		}
		if s.buf[s.pos] <= 32 {
			break
		}
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func appendInt(b []byte, v int64) []byte {
	if v == 0 {
		return append(b, '0')
	}
	var buf [32]byte
	i := 32
	for v > 0 {
		i--
		buf[i] = byte(v%10 + '0')
		v /= 10
	}
	return append(b, buf[i:]...)
}

func main() {
	sc := newScanner(os.Stdin)
	n := sc.nextInt()
	if n == 0 {
		return
	}

	adj := make([][]int, n)
	for i := 0; i < n; i++ {
		adj[i] = make([]int, n)
	}

	for i := 0; i < n-1; i++ {
		for j := 0; j < n-1-i; j++ {
			w := sc.nextInt()
			adj[i][i+j+1] = w
			adj[i+j+1][i] = w
		}
	}

	inTree := make([]bool, n)
	minEdge := make([]int, n)
	parent := make([]int, n)
	for i := 0; i < n; i++ {
		minEdge[i] = 2e9
		parent[i] = -1
	}

	minEdge[0] = 0
	type Edge struct {
		to, w int
	}
	mst := make([][]Edge, n)

	for i := 0; i < n; i++ {
		u := -1
		for j := 0; j < n; j++ {
			if !inTree[j] && (u == -1 || minEdge[j] < minEdge[u]) {
				u = j
			}
		}

		inTree[u] = true
		if parent[u] != -1 {
			mst[u] = append(mst[u], Edge{parent[u], minEdge[u]})
			mst[parent[u]] = append(mst[parent[u]], Edge{u, minEdge[u]})
		}

		for v := 0; v < n; v++ {
			if !inTree[v] && adj[u][v] < minEdge[v] {
				minEdge[v] = adj[u][v]
				parent[v] = u
			}
		}
	}

	out := make([]byte, 0, n*20)
	for r := 0; r < n; r++ {
		var sum int64 = 0
		var dfs func(u, p, maxW int)
		dfs = func(u, p, maxW int) {
			if u != r {
				sum += int64(maxW)
			}
			for _, edge := range mst[u] {
				if edge.to != p {
					newMax := maxW
					if edge.w > newMax {
						newMax = edge.w
					}
					dfs(edge.to, u, newMax)
				}
			}
		}
		dfs(r, -1, 0)
		out = appendInt(out, sum)
		out = append(out, ' ')
	}
	out[len(out)-1] = '\n'
	os.Stdout.Write(out)
}
```