package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

func solve(in *bufio.Reader, out *bufio.Writer) {
	var n, m_edges int
	fmt.Fscan(in, &n, &m_edges)

	adj := make([][]int, n+1)
	for i := 0; i < m_edges; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	var f int
	fmt.Fscan(in, &f)
	h := make([]int, f+1)
	for i := 1; i <= f; i++ {
		fmt.Fscan(in, &h[i])
	}

	var k int
	fmt.Fscan(in, &k)
	p := make([]int, k)
	is_no_car := make([]bool, f+1)
	for i := 0; i < k; i++ {
		fmt.Fscan(in, &p[i])
		is_no_car[p[i]] = true
	}

	c := make([]int, k)
	for i, pi := range p {
		c[i] = h[pi]
	}

	car_dests := make([]int, 0, f-k)
	for i := 1; i <= f; i++ {
		if !is_no_car[i] {
			car_dests = append(car_dests, h[i])
		}
	}

	bfs := func(start int) []int {
		dist := make([]int, n+1)
		for i := 1; i <= n; i++ {
			dist[i] = -1
		}
		dist[start] = 0
		q := []int{start}
		for len(q) > 0 {
			u := q[0]
			q = q[1:]
			for _, v := range adj[u] {
				if dist[v] == -1 {
					dist[v] = dist[u] + 1
					q = append(q, v)
				}
			}
		}
		return dist
	}

	D0 := bfs(1)
	Dc := make([][]int, k)
	for i := 0; i < k; i++ {
		Dc[i] = bfs(c[i])
	}

	validPath := make([][]bool, 1<<k)
	for i := 0; i < (1<<k); i++ {
		validPath[i] = make([]bool, k)
	}

	for i := 0; i < k; i++ {
		if D0[c[i]] != -1 {
			validPath[1<<i][i] = true
		}
	}

	for mask := 1; mask < (1<<k); mask++ {
		for i := 0; i < k; i++ {
			if validPath[mask][i] {
				for j := 0; j < k; j++ {
					if (mask & (1 << j)) == 0 {
						if D0[c[i]] != -1 && Dc[i][c[j]] != -1 && D0[c[j]] != -1 {
							if D0[c[i]]+Dc[i][c[j]] == D0[c[j]] {
								validPath[mask|(1<<j)][j] = true
							}
						}
					}
				}
			}
		}
	}

	maximal_valid := make([][]int, n+1)
	for v := 1; v <= n; v++ {
		if D0[v] == -1 {
			continue
		}

		var valid []int
		for mask := 1; mask < (1<<k); mask++ {
			for i := 0; i < k; i++ {
				if (mask&(1<<i)) != 0 && validPath[mask][i] {
					if Dc[i][v] != -1 && D0[c[i]]+Dc[i][v] == D0[v] {
						valid = append(valid, mask)
						break
					}
				}
			}
		}

		var max_v []int
		for _, m := range valid {
			is_max := true
			for _, m2 := range valid {
				if m != m2 && (m&m2) == m {
					is_max = false
					break
				}
			}
			if is_max {
				max_v = append(max_v, m)
			}
		}
		maximal_valid[v] = max_v
	}

	dp := make([]bool, 1<<k)
	dp[0] = true

	count := make([]int, n+1)
	for _, v := range car_dests {
		count[v]++
	}

	for v := 1; v <= n; v++ {
		if count[v] == 0 {
			continue
		}
		if len(maximal_valid[v]) == 0 {
			continue
		}

		for c_idx := 0; c_idx < count[v]; c_idx++ {
			new_dp := make([]bool, 1<<k)
			copy(new_dp, dp)
			changed := false
			for _, m := range maximal_valid[v] {
				for i := 0; i < (1<<k); i++ {
					if dp[i] && !new_dp[i|m] {
						new_dp[i|m] = true
						changed = true
					}
				}
			}
			dp = new_dp
			if !changed {
				break
			}
		}
	}

	max_pop := 0
	for i := 0; i < (1<<k); i++ {
		if dp[i] {
			ones := bits.OnesCount(uint(i))
			if ones > max_pop {
				max_pop = ones
			}
		}
	}

	fmt.Fprintln(out, k-max_pop)
}

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

	var t int
	fmt.Fscan(in, &t)
	for tc := 0; tc < t; tc++ {
		solve(in, out)
	}
}