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
import sys,io,os
from os import path
from collections import Counter,defaultdict
if(path.exists('input.txt')):
     sys.stdin = open('input.txt','r')
     sys.stdout = open('output.txt','w')
else:
     input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

def dfs(graph,color,visited,i,key):
    stack=[i]
    while(stack):
        v=stack.pop()
   #     print(v)
        if(visited[v]):
            continue
        visited[v]=True
        for j in graph[v]:      
            if visited[j]==True:
                continue
            if color[j]!=color[i]:
             #   print(color[j],color[i])
          #      print(v+1,j+1,i+1)
                return j,v
            stack.append(j)
    return -1,-1

def main():
    n=int(input())
    graph=[[] for i in range(n)]
    for i in range(n-1):
        a,b=list(map(int,input().split()))
        graph[a-1].append(b-1)
        graph[b-1].append(a-1)
    color=list(map(int,input().split()))
    visited=[False]*n
   # motor=[[] for i in range(n)]
    for j in graph[0]:
        visited[0]=True
        p=dfs(graph,color,visited,j,1)
        if p!=(-1,-1):
       #     p=j
            m,e=p
            if color[0]!=color[j]:
                new=j
            else:
                new=m
      #      print(new+1)
           # print(p+1)
       #     print(new)
            visited=[False]*n
            visited[new]=True
            for i in graph[new]:
                k=dfs(graph,color,visited,i,0)
                if k!=(-1,-1):
                    visited=[False]*n
                    new=j
                    visited[new]=True
                   # print(j,"JAA")
                    for ii in graph[new]:
                        k=dfs(graph,color,visited,ii,0)
                        if k!=(-1,-1):
                            print("NO")
                            return
                    print("YES")
                    print(new+1)
                    return
            print("YES")
            print(new+1)
            return
    print("YES")
    print(1)    
    



for _ in range(1):
    main()
