package main

import (
	"bufio"
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func solvePairInto(rhs, out []int64) bool {
	n := len(rhs)
	if n == 1 {
		if rhs[0]%2 != 0 {
			return false
		}
		out[0] = rhs[0] / 2
		return true
	}
	f := rhs[0]
	for i := 1; i <= n-2; i++ {
		f = rhs[i] - f
	}
	val := rhs[n-1] - f
	if val%2 != 0 {
		return false
	}
	z := val / 2
	out[n-1] = z
	out[0] = rhs[0] - z
	for i := 1; i <= n-2; i++ {
		out[i] = rhs[i] - out[i-1]
	}
	return true
}

func writeInt64(w *bufio.Writer, x int64) {
	if x == 0 {
		w.WriteByte('0')
		return
	}
	if x < 0 {
		w.WriteByte('-')
		x = -x
	}
	var buf [20]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	w.Write(buf[i:])
}

func main() {
	fs := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := fs.NextInt()

	var aBuf, rhsBuf, tmpBuf, xBuf []int64

	for ; t > 0; t-- {
		n := fs.NextInt()

		if len(aBuf) < n {
			aBuf = make([]int64, n)
			rhsBuf = make([]int64, n)
			tmpBuf = make([]int64, n)
			xBuf = make([]int64, n)
		}

		a := aBuf[:n]
		rhs := rhsBuf[:n]
		tmp := tmpBuf[:n]
		x := xBuf[:n]

		for i := 0; i < n; i++ {
			a[i] = int64(fs.NextInt())
		}

		found := false
		for cand := 0; cand < 4 && !found; cand++ {
			c := int64(cand)
			for i := 0; i < n; i++ {
				rhs[i] = c - a[i]
			}
			if !solvePairInto(rhs, tmp) {
				continue
			}
			if !solvePairInto(tmp, x) {
				continue
			}
			found = true
		}

		if !found {
			writeInt64(out, -1)
			out.WriteByte('\n')
			continue
		}

		minV := x[0]
		for i := 1; i < n; i++ {
			if x[i] < minV {
				minV = x[i]
			}
		}
		shift := int64(0)
		if minV < 0 {
			shift = -minV
		}

		for i := 0; i < n; i++ {
			var val int64
			if i == 0 {
				val = x[n-1] + shift
			} else {
				val = x[i-1] + shift
			}
			writeInt64(out, val)
			if i+1 < n {
				out.WriteByte(' ')
			} else {
				out.WriteByte('\n')
			}
		}
	}
}