Each New Year Timofey and his friends cut down a tree of *n* vertices and bring it home. After that they paint all the *n* its vertices, so that the *i*-th vertex gets color *c*<sub class="lower-index">*i*</sub>.

Now it's time for Timofey birthday, and his mother asked him to remove the tree. Timofey removes the tree in the following way: he takes some vertex in hands, while all the other vertices move down so that the tree becomes rooted at the chosen vertex. After that Timofey brings the tree to a trash can.

Timofey doesn't like it when many colors are mixing together. A subtree annoys him if there are vertices of different color in it. Timofey wants to find a vertex which he should take in hands so that there are no subtrees that annoy him. He doesn't consider the whole tree as a subtree since he can't see the color of the root vertex.

A subtree of some vertex is a subgraph containing that vertex and all its descendants.

Your task is to determine if there is a vertex, taking which in hands Timofey wouldn't be annoyed.
The first line contains single integer *n* (2 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the number of vertices in the tree.

Each of the next *n* - 1 lines contains two integers *u* and *v* (1 ≤ *u*, *v* ≤ *n*, *u* ≠ *v*), denoting there is an edge between vertices *u* and *v*. It is guaranteed that the given graph is a tree.

The next line contains *n* integers *c*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">2</sub>, ..., *c*<sub class="lower-index">*n*</sub> (1 ≤ *c*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">5</sup>), denoting the colors of the vertices.
none
4
1 2
2 3
3 4
1 2 1 1
YES
2
3
1 2
2 3
1 2 3
YES
2
4
1 2
2 3
3 4
1 2 1 2
NO
3
2 1
2 3
1 2 3
YES
2
4
1 2
2 4
4 3
1 1 3 2
YES
4
2
1 2
1 1
YES
1
10
5 7
4 5
10 2
3 6
1 2
3 4
8 5
4 9
2 3
15 15 15 15 5 15 26 18 15 15
YES
5
8
1 2
1 3
3 5
3 6
1 4
4 7
4 8
1 3 1 1 1 1 1 2
NO
3
2 1
2 3
4 4 4
YES
1
3
1 2
1 3
1 2 2
YES
1
4
1 4
2 4
3 4
1 2 3 1
YES
4
4
1 2
1 3
1 4
1 2 3 4
YES
1
9
1 2
2 3
3 4
4 5
2 7
7 6
2 8
8 9
1 1 2 2 2 3 3 4 4
YES
2
3
2 1
2 3
4 4 5
YES
2
4
1 2
2 3
3 4
1 2 2 1
NO
from sys import stdin as fin
# fin = open("cfr395c.in", "r")

def cnt_colors(v):
    global g, used, color, as_mono
    used[v] += 1
    cnt = 0
    # ccol1 = ccol2 = None
    ccol = None
    s_mono = True
    for i in range(len(g[v])):
        [u, mono] = g[v][i]
        if not used[u]:
            mono = cnt_colors(u)
            g[v][i] = [u, mono]
            if (ccol is not None and color[u] != ccol) or not as_mono[u]:
                s_mono = False
            elif ccol is None:
                ccol = color[u]
            # elif ccol2 is None:
            #     ccol2 = color[u]
    if ccol is not None and color[v] != ccol:
        s_mono = False
    as_mono[v] = s_mono
    return s_mono

def find_root(v, p):
    global g, used, color, as_mono, hold
    used[v] += 1
    s_mono = True
    for [u, mono] in g[v]:
        if used[u] < 2 and not as_mono[u]:
            s_mono = False
    if p is not None:
        for [u, mono] in g[p]:
            if u != v and not hold[u] and (not as_mono[u] or color[u] != color[p]):
                s_mono = False
                break
            else:
                hold[p] = True

    for [u, mono] in g[v]:
        if used[u] < 2:
            if find_root(u, v):
                return True
    #     if (ccol is not None and color[u] != ccol) or not mono:
    #         s_mono = False
    #     elif ccol is None:
    #         ccol = color[u]
    if s_mono:
        print("YES")
        print(v + 1)
    hold[p] = False
    return s_mono



# n, m = map(fin.readline().split())
n = int(fin.readline())
g = [[] for i in range(n)]
for i in range(n - 1):
    s, t = map(int, fin.readline().split())
    s, t = s - 1, t - 1
    g[s].append([t, None])
    g[t].append([s, None])

color = tuple(map(int, fin.readline().split()))
used = [0] * n
as_mono = [True] * n
hold = [False] * n
cnt_colors(0)
if not find_root(0, None):
    print("NO")