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 typing import Collection


n = int(input())
children = [[] for _ in range(n)]
for _ in range(n-1):
    a,b = map(lambda a:int(a)-1,input().split(' '))
    a,b = (min(a,b),max(a,b))
    children[a].append(b)
    children[b].append(a)
colours = list(map(int,input().split(' ')))
def dfs_stack(adjacency:list,start_node:int,colours:list):
    #Current vertex stack
    vstack = [start_node]
    #Return stack
    rstack = []
    #First we build our visit stack
    #and index list
    index = [-1 for _ in adjacency]
    parent = [-1 for _ in adjacency]
    i = 0
    directed_adjacency = [[] for _ in adjacency]
    rcolours = colours.copy()
    temp_stack = [start_node]
    while len(temp_stack)!=0:
        current = temp_stack.pop()
        if index[current]==-1:
            index[current] = i
            i+=1
        for child in adjacency[current]:
            if index[child]==-1:
                directed_adjacency[current].append(child)
                parent[child] = current
                vstack.append(child)
                temp_stack.append(current)
                temp_stack.append(child)
                break
    #Now we start visiting them from the bottom
    while len(vstack)!=0:
        current = vstack.pop()
        #If it has no children
        if len(directed_adjacency[current])==0:
            rstack.append(colours[current])
        else:
            children = set([rstack.pop() for _ in range(len(directed_adjacency[current]))])
            if len(children)==1:
                ccol = children.pop()
                colour = ccol if ccol==colours[current] else -1
            else:
                colour = -1
            rcolours[current]=colour
            rstack.append(
                colour
            )
    return (rcolours,directed_adjacency,index)
rcolours,children,index = dfs_stack(children,0,colours)
#print(rcolours)
#print(colours)
#print(children)
mixed = [(index[i],i) for i in range(len(index)) if rcolours[i]==-1]
#print(mixed)
if len(mixed)==0:
    print("YES")
    print(0)
else:
    firstmixed = sorted(mixed)[0][1]
    current = firstmixed
    must_be_final = False
    while True:
        if len(children[current])==0:
            print("NO")
            break
        crcolours = [rcolours[i] for i in children[current]]
        ccolours = [colours[i] for i in children[current]]
        count = crcolours.count(-1)
        if count==0:
            print("YES")
            print(current+1)
            break
        elif count>1:
            print("NO")
            break
        elif not must_be_final:
            child = children[current][crcolours.index(-1)]
            if (colours[child]==colours[current] or
                ccolours.count(colours[child])==1):
                current = child
                must_be_final=True
                continue
            else:
                print("NO")
                break
        else:
            print("NO")
            break

 	   		 	 	 	 	  							    		