package main

import (
	"bufio"
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') && fs.data[fs.idx] != '-' {
		fs.idx++
	}
	sign := 1
	if fs.idx < fs.n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val * sign
}

type Pair struct {
	node   int
	parent int
}

func ok(root int, adj [][]int, color []int) bool {
	stack := make([]Pair, 0)
	for _, nei := range adj[root] {
		target := color[nei]
		stack = stack[:0]
		stack = append(stack, Pair{nei, root})
		for len(stack) > 0 {
			cur := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			if color[cur.node] != target {
				return false
			}
			for _, nxt := range adj[cur.node] {
				if nxt != cur.parent {
					stack = append(stack, Pair{nxt, cur.node})
				}
			}
		}
	}
	return true
}

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

	n := in.NextInt()
	adj := make([][]int, n+1)
	u := make([]int, n-1)
	v := make([]int, n-1)

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

	color := make([]int, n+1)
	for i := 1; i <= n; i++ {
		color[i] = in.NextInt()
	}

	a, b := -1, -1
	for i := 0; i < n-1; i++ {
		if color[u[i]] != color[v[i]] {
			a, b = u[i], v[i]
			break
		}
	}

	if a == -1 {
		out.WriteString("YES\n1\n")
		return
	}

	if ok(a, adj, color) {
		out.WriteString("YES\n")
		writeInt(out, a)
		out.WriteByte('\n')
		return
	}
	if ok(b, adj, color) {
		out.WriteString("YES\n")
		writeInt(out, b)
		out.WriteByte('\n')
		return
	}

	out.WriteString("NO\n")
}

func writeInt(out *bufio.Writer, x int) {
	if x == 0 {
		out.WriteByte('0')
		return
	}
	if x < 0 {
		out.WriteByte('-')
		x = -x
	}
	var buf [20]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	out.Write(buf[i:])
}