```go
package main

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

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func lcm(a, b int64) int64 {
	return a / gcd(a, b) * b
}

func factorize(x int64) map[int64]int {
	f := make(map[int64]int)
	for p := int64(2); p*p <= x; p++ {
		if x%p == 0 {
			c := 0
			for x%p == 0 {
				x /= p
				c++
			}
			f[p] = c
		}
	}
	if x > 1 {
		f[x]++
	}
	return f
}

func genDivsFromFactors(f map[int64]int) []int64 {
	divs := []int64{1}
	for p, e := range f {
		cur := make([]int64, 0, len(divs)*(e+1))
		pow := int64(1)
		for i := 0; i <= e; i++ {
			for _, d := range divs {
				cur = append(cur, d*pow)
			}
			pow *= p
		}
		divs = cur
	}
	sort.Slice(divs, func(i, j int) bool { return divs[i] < divs[j] })
	return divs
}

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

	var t int
	fmt.Fscan(in, &t)

	for ; t > 0; t-- {
		var n int
		fmt.Fscan(in, &n)
		a := make([]int64, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &a[i])
		}
		sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })

		set := make(map[int64]struct{}, n)
		for _, v := range a {
			set[v] = struct{}{}
		}

		x := a[0] * a[n-1]
		ok := true
		for i := 0; i < n; i++ {
			if x%a[i] != 0 {
				ok = false
				break
			}
		}

		if ok {
			f := factorize(x)
			divs := genDivsFromFactors(f)
			inner := make([]int64, 0, len(divs))
			for _, d := range divs {
				if d != 1 && d != x {
					inner = append(inner, d)
				}
			}
			if len(inner) != n {
				ok = false
			} else {
				for i := 0; i < n; i++ {
					if inner[i] != a[i] {
						ok = false
						break
					}
				}
			}
		}

		if !ok {
			fmt.Fprintln(out, -1)
		} else {
			fmt.Fprintln(out, x)
		}
	}
}
```