package main

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

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

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	adj := make([][]int, n+1)
	hasFather := make([]bool, n+1)

	for i := 0; i < m; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], v)
		hasFather[v] = true
	}

	a := make([]int, n+1)
	inU := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &a[i])
		inU[a[i]] = true
	}

	depth := make([]int, n+1)
	closest := make([]int, n+1)

	var dfs func(int, int, int)
	dfs = func(u, d, anc int) {
		depth[u] = d
		curr := anc
		if inU[u] {
			curr = u
		}
		closest[u] = curr
		for _, v := range adj[u] {
			dfs(v, d+1, curr)
		}
	}

	for i := 1; i <= n; i++ {
		if !hasFather[i] {
			dfs(i, 0, -1)
		}
	}

	for i := 1; i <= n; i++ {
		if closest[i] != a[i] {
			fmt.Fprintln(out, -1)
			return
		}
	}

	type Candidate struct {
		id, d int
	}
	candidates := make([]Candidate, 0)
	for i := 1; i <= n; i++ {
		if inU[i] {
			candidates = append(candidates, Candidate{i, depth[i]})
		}
	}

	sort.Slice(candidates, func(i, j int) bool {
		return candidates[i].d > candidates[j].d
	})

	fmt.Fprintln(out, len(candidates))
	for _, c := range candidates {
		fmt.Fprintln(out, c.id)
	}
}