package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, len(buf))
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	t := 0
	for _, b := range scanner.Bytes() {
		t = t*10 + int(b-'0')
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for tc := 0; tc < t; tc++ {
		n := readInt()
		setsFlat := make([]int, 0)
		setsHead := make([]int, n+1)

		for i := 0; i < n; i++ {
			k := readInt()
			setsHead[i] = len(setsFlat)
			for j := 0; j < k; j++ {
				setsFlat = append(setsFlat, readInt())
			}
		}
		setsHead[n] = len(setsFlat)
		totalK := len(setsFlat)

		allElems := make([]int, totalK)
		copy(allElems, setsFlat)
		sort.Ints(allElems)

		U := 0
		for i := 0; i < len(allElems); i++ {
			if i == 0 || allElems[i] != allElems[i-1] {
				allElems[U] = allElems[i]
				U++
			}
		}
		allElems = allElems[:U]

		for i := 0; i < totalK; i++ {
			val := setsFlat[i]
			l, r := 0, U-1
			for l <= r {
				m := (l + r) >> 1
				if allElems[m] == val {
					setsFlat[i] = m + 1
					break
				} else if allElems[m] < val {
					l = m + 1
				} else {
					r = m - 1
				}
			}
		}

		freq := make([]int, U+1)
		for _, x := range setsFlat {
			freq[x]++
		}

		posHead := make([]int, U+2)
		for x := 1; x <= U; x++ {
			posHead[x+1] = posHead[x] + freq[x]
		}
		posCur := make([]int, U+1)
		copy(posCur, posHead)

		posData := make([]int, totalK)
		for i := 0; i < n; i++ {
			set := setsFlat[setsHead[i]:setsHead[i+1]]
			for _, x := range set {
				posData[posCur[x]] = i
				posCur[x]++
			}
		}

		B := int(math.Sqrt(float64(totalK)))
		if B < 2 {
			B = 2
		}

		count := make([]int, n)
		found := false
		var ans1, ans2 int

		for i := 0; i < n; i++ {
			set := setsFlat[setsHead[i]:setsHead[i+1]]
			for _, x := range set {
				if freq[x] >= B {
					continue
				}
				p := posData[posHead[x]:posHead[x+1]]
				for _, j := range p {
					if j >= i {
						break
					}
					if count[j] == 1 {
						ans1, ans2 = j, i
						found = true
						break
					}
					count[j] = 1
				}
				if found {
					break
				}
			}
			if found {
				break
			}
			for _, x := range set {
				if freq[x] >= B {
					continue
				}
				p := posData[posHead[x]:posHead[x+1]]
				for _, j := range p {
					if j >= i {
						break
					}
					count[j] = 0
				}
			}
		}

		if !found {
			seenIn := make([]int, U+1)
			for i := 0; i <= U; i++ {
				seenIn[i] = -1
			}

			for x := 1; x <= U; x++ {
				if freq[x] < B {
					continue
				}
				p := posData[posHead[x]:posHead[x+1]]
				for _, i := range p {
					set := setsFlat[setsHead[i]:setsHead[i+1]]
					for _, y := range set {
						if y == x {
							continue
						}
						if seenIn[y] != -1 {
							ans1, ans2 = seenIn[y], i
							found = true
							break
						}
						seenIn[y] = i
					}
					if found {
						break
					}
				}
				if found {
					break
				}
				for _, i := range p {
					set := setsFlat[setsHead[i]:setsHead[i+1]]
					for _, y := range set {
						seenIn[y] = -1
					}
				}
			}
		}

		if found {
			fmt.Fprintf(out, "%d %d\n", ans1+1, ans2+1)
		} else {
			fmt.Fprintln(out, "-1")
		}
	}
}