```go
package main

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

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

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

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

		var k int
		fmt.Fscan(reader, &k)
		p := make([]int, k)
		for i := 0; i < k; i++ {
			fmt.Fscan(reader, &p[i])
			p[i]--
		}

		dist1 := bfs(1, adj, n)

		home := make([]int, k)
		distFriends := make([][]int, k)
		for i := 0; i < k; i++ {
			home[i] = h[p[i]]
			distFriends[i] = bfs(home[i], adj, n)
		}

		isDriver := make([]bool, f)
		for i := 0; i < f; i++ {
			isDriver[i] = true
		}
		for _, idx := range p {
			isDriver[idx] = false
		}

		drivers := []int{}
		for i := 0; i < f; i++ {
			if isDriver[i] {
				drivers = append(drivers, h[i])
			}
		}

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

		for _, d := range drivers {
			if dist1[d] < 0 {
				continue
			}

			maskReachable := 0
			for i := 0; i < k; i++ {
				if dist1[home[i]] >= 0 && distFriends[i][d] >= 0 && dist1[home[i]]+distFriends[i][d] == dist1[d] {
					maskReachable |= (1 << i)
				}
			}

			validSubsets := []int{0}
			sub := maskReachable
			for {
				if sub != 0 && isValidChain(sub, dist1, distFriends, home, d) {
					validSubsets = append(validSubsets, sub)
				}
				if sub == 0 {
					break
				}
				sub = (sub - 1) & maskReachable
			}

			newDp := make([]bool, 1<<k)
			copy(newDp, dp)
			for mask := 0; mask < (1 << k); mask++ {
				if dp[mask] {
					for _, s := range validSubsets {
						if mask&s == 0 {
							newDp[mask|s] = true
						}
					}
				}
			}
			dp = newDp
		}

		maxCovered := 0
		for mask := 0; mask < (1 << k); mask++ {
			if dp[mask] {
				cnt := bits.OnesCount(uint(mask))
				if cnt > maxCovered {
					maxCovered = cnt
				}
			}
		}

		fmt.Fprintln(writer, k-maxCovered)
	}
}

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

func isValidChain(mask int, dist1 []int, distFriends [][]int, home []int, driverVertex int) bool {
	if mask == 0 {
		return true
	}
	idxs := []int{}
	for i := 0; i < len(home); i++ {
		if mask&(1<<i) != 0 {
			idxs = append(idxs, i)
		}
	}
	sort.Slice(idxs, func(i, j int) bool {
		return dist1[home[idxs[i]]] < dist1[home[idxs[j]]]
	})
	for i := 0; i < len(idxs)-1; i++ {
		u := idxs[i]
		v := idxs[i+1]
		if dist1[home[u]]+distFriends[u][home[v]] != dist1[home[v]] {
			return false
		}
	}
	last := idxs[len(idxs)-1]
	if dist1[home[last]]+distFriends[last][driverVertex] != dist1[driverVertex] {
		return false
	}
	return true
}
```