package main

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

var (
	n        int
	segments [][]int
	ans      []int
	visited  map[State]bool
)

type State [4]uint64

func hasBit(s State, i int) bool {
	return (s[i/64] & (1 << (i % 64))) != 0
}

func clearBit(s State, i int) State {
	s[i/64] &^= (1 << (i % 64))
	return s
}

func setBit(s State, i int) State {
	s[i/64] |= (1 << (i % 64))
	return s
}

func isValid(p []int) bool {
	pos := make([]int, n+1)
	for i, x := range p {
		pos[x] = i
	}

	seenR := make([]bool, n)

	for i := 0; i < n-1; i++ {
		seg := segments[i]
		minP := n
		maxP := -1
		for _, x := range seg {
			pIdx := pos[x]
			if pIdx < minP {
				minP = pIdx
			}
			if pIdx > maxP {
				maxP = pIdx
			}
		}
		if maxP-minP+1 != len(seg) {
			return false
		}
		if maxP == 0 {
			return false
		}
		if seenR[maxP] {
			return false
		}
		seenR[maxP] = true
	}
	return true
}

func solve(state State, p []int) bool {
	if visited[state] {
		return false
	}
	visited[state] = true

	remCount := 0
	var lastSegIdx int
	for i := 0; i < n-1; i++ {
		if hasBit(state, i) {
			remCount++
			lastSegIdx = i
		}
	}

	if remCount == 1 {
		seg := segments[lastSegIdx]
		if len(seg) == 2 {
			p1 := append([]int{seg[0], seg[1]}, p...)
			if isValid(p1) {
				ans = p1
				return true
			}
			p2 := append([]int{seg[1], seg[0]}, p...)
			if isValid(p2) {
				ans = p2
				return true
			}
		}
		return false
	}

	freq := make(map[int]int)
	segmentOf := make(map[int]int)

	for i := 0; i < n-1; i++ {
		if hasBit(state, i) {
			for _, val := range segments[i] {
				freq[val]++
				segmentOf[val] = i
			}
		}
	}

	var cands []int
	for val, count := range freq {
		if count == 1 {
			cands = append(cands, val)
		}
	}

	sort.Slice(cands, func(i, j int) bool {
		return len(segments[segmentOf[cands[i]]]) > len(segments[segmentOf[cands[j]]])
	})

	for _, val := range cands {
		segIdx := segmentOf[val]
		nextState := clearBit(state, segIdx)
		nextP := append([]int{val}, p...)
		if solve(nextState, nextP) {
			return true
		}
	}

	return false
}

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++ {
		fmt.Fscan(reader, &n)
		segments = make([][]int, n-1)
		for i := 0; i < n-1; i++ {
			var k int
			fmt.Fscan(reader, &k)
			seg := make([]int, k)
			for j := 0; j < k; j++ {
				fmt.Fscan(reader, &seg[j])
			}
			segments[i] = seg
		}

		visited = make(map[State]bool)
		var startState State
		for i := 0; i < n-1; i++ {
			startState = setBit(startState, i)
		}

		ans = nil
		solve(startState, []int{})

		for i, val := range ans {
			if i > 0 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprint(writer, val)
		}
		fmt.Fprintln(writer)
	}
}