package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var m int
		fmt.Fscan(reader, &m)
		b := make([]int, m)
		sum := 0
		prod := 1
		N := 1
		for i := 0; i < m; i++ {
			fmt.Fscan(reader, &b[i])
			sum += b[i]
			prod *= b[i]
			N *= (b[i] + 1)
		}

		valid := true
		if m == 1 {
			if b[0] > 3 {
				valid = false
			}
		} else if m == 2 {
			if prod > sum+1 {
				valid = false
			}
		} else {
			if prod > sum {
				valid = false
			}
		}

		if !valid {
			fmt.Fprintln(writer, "-1")
			continue
		}

		idToU := make([][]int, N)
		for i := 0; i < N; i++ {
			u := make([]int, m)
			tmp := i
			for j := 0; j < m; j++ {
				u[j] = tmp % (b[j] + 1)
				tmp /= (b[j] + 1)
			}
			idToU[i] = u
		}

		initialDegree := make([]int, N)
		for i := 1; i < N; i++ {
			u := idToU[i]
			deg := 0
			for k := 0; k < m; k++ {
				if u[k] >= 1 {
					ways := 1
					if u[k] == 1 {
						ways = b[k]
					}
					for j := 0; j < m; j++ {
						if j != k {
							if u[j] == 0 {
								ways *= (b[j] + 1)
							}
						}
					}
					deg += ways
				}
			}
			ones := 0
			others := 0
			for j := 0; j < m; j++ {
				if u[j] == 1 {
					ones++
				} else if u[j] > 1 {
					others++
				}
			}
			if ones == 1 && others == 0 {
				deg--
			}
			initialDegree[i] = deg
		}

		start := 1
		minDeg := initialDegree[1]
		for i := 2; i < N; i++ {
			if initialDegree[i] < minDeg {
				minDeg = initialDegree[i]
				start = i
			}
		}

		visited := make([]bool, N)
		path := make([]int, N-1)

		var dfs func(u int, count int) bool
		dfs = func(u int, count int) bool {
			path[count] = u
			if count == N-2 {
				return true
			}
			visited[u] = true

			uArr := idToU[u]
			var neighbors []int

			for k := 0; k < m; k++ {
				if uArr[k] >= 1 {
					var generate func(idx int, currentId int, mult int)
					generate = func(idx int, currentId int, mult int) {
						if idx == m {
							if !visited[currentId] && currentId != u {
								neighbors = append(neighbors, currentId)
							}
							return
						}
						nextMult := mult * (b[idx] + 1)
						if idx == k {
							if uArr[k] >= 2 {
								generate(idx+1, currentId+1*mult, nextMult)
							} else {
								for val := 1; val <= b[idx]; val++ {
									generate(idx+1, currentId+val*mult, nextMult)
								}
							}
						} else {
							if uArr[idx] >= 1 {
								generate(idx+1, currentId, nextMult)
							} else {
								for val := 0; val <= b[idx]; val++ {
									generate(idx+1, currentId+val*mult, nextMult)
								}
							}
						}
					}
					generate(0, 0, 1)
				}
			}

			sort.Slice(neighbors, func(i, j int) bool {
				if initialDegree[neighbors[i]] == initialDegree[neighbors[j]] {
					return neighbors[i] < neighbors[j]
				}
				return initialDegree[neighbors[i]] < initialDegree[neighbors[j]]
			})

			for _, v := range neighbors {
				if dfs(v, count+1) {
					return true
				}
			}

			visited[u] = false
			return false
		}

		dfs(start, 0)

		for i := 0; i < N-1; i++ {
			u := idToU[path[i]]
			for j := 0; j < m; j++ {
				if j > 0 {
					fmt.Fprint(writer, " ")
				}
				fmt.Fprint(writer, u[j])
			}
			fmt.Fprintln(writer)
		}
	}
}