package main

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

func readInt(in *bufio.Reader) int {
	var x int
	var c byte
	var err error
	for {
		c, err = in.ReadByte()
		if err != nil {
			return 0
		}
		if c >= '0' && c <= '9' {
			break
		}
	}
	for {
		x = x*10 + int(c-'0')
		c, err = in.ReadByte()
		if err != nil || c < '0' || c > '9' {
			break
		}
	}
	return x
}

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

	t := readInt(in)

	var visited [1 << 20]int
	var dp [1 << 20]int
	visitID := 0

	queue := make([]int, 0, 1<<20)

	for tc := 0; tc < t; tc++ {
		n := readInt(in)

		adj := make([][]int, n+1)
		for i := 0; i < n-1; i++ {
			u := readInt(in)
			v := readInt(in)
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		k := readInt(in)

		val := make([]int, n+1)
		for i := 0; i < k; i++ {
			u := readInt(in)
			v := readInt(in)
			val[u] ^= 1 << i
			val[v] ^= 1 << i
		}

		subtree_val := make([]int, n+1)
		var dfs func(int, int) int
		dfs = func(u, p int) int {
			mask := val[u]
			for _, v := range adj[u] {
				if v != p {
					mask ^= dfs(v, u)
				}
			}
			subtree_val[u] = mask
			return mask
		}
		dfs(1, 0)

		sort.Ints(subtree_val)
		var masks []int
		for i, m := range subtree_val {
			if m == 0 {
				continue
			}
			if i == 0 || m != subtree_val[i-1] {
				masks = append(masks, m)
			}
		}

		target := (1 << k) - 1
		if target == 0 {
			fmt.Fprintln(out, 0)
			continue
		}

		visitID++
		queue = queue[:0]
		queue = append(queue, 0)
		visited[0] = visitID
		dp[0] = 0

		ans := -1
		head := 0
		for head < len(queue) {
			curr := queue[head]
			head++

			if curr == target {
				ans = dp[curr]
				break
			}

			for _, m := range masks {
				nxt := curr | m
				if visited[nxt] != visitID {
					visited[nxt] = visitID
					dp[nxt] = dp[curr] + 1
					if nxt == target {
						ans = dp[nxt]
						break
					}
					queue = append(queue, nxt)
				}
			}
			if ans != -1 {
				break
			}
		}

		fmt.Fprintln(out, ans)
	}
}