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
adj = [[] for i in range(14)]
pure = [False for i in range(14)]
colors = []
success = False

def dfs(x, father):
    # print('searching: ', x, 'from ', father)
    global colors
    global pure
    global adj
    flag = False
    leaf = 0
    c = -1
    for child in adj[x]:
        if (child != father):
            # print(x, ' has a child ', child)
            dfs(child, x)
            leaf += 1
    if leaf == 0:
        pure[x] = True
        return
    for child in adj[x]:
        if child == father:
            continue
        if not pure[child]:
            pure[x] = False
            return
        else:
            if c == -1:
                c = colors[child]
            elif c != colors[child]:
                pure[x] = False
                return
    # print('Testing:', x, '|child:', c, '|color:', colors[x])
    pure[x] = (c == colors[x])

def check(x, father):
    global success
    # print('Checking:', x)
    cnt = len(adj[x])-1
    for i in adj[x]:
        if i == father:
            continue
        if pure[i]:
            cnt -= 1
    if cnt == 0:
        print('YES')
        print(x)
        success = True
        return
    if (colors[father] != colors[x]):
        return
    for kid in adj[x]:
        if kid == father:
            continue
        flag = True
        for otherkid in adj[x]:
            if otherkid == kid:
                continue
            if colors[otherkid] != colors[x] or not pure[otherkid]:
                flag = False
                break
        if flag:
            check(kid, x)

def main():
    global colors
    global adj
    root = 1
    n = int(input())
    for i in range(n-1):
        [u, v] = map(int, input().split(' '))
        adj[u].append(v)
        adj[v].append(u)
    colors = list(map(int,input().split()))
    colors = [-1] + colors
    dfs(root, 0)
    # print(adj)
    # print(colors)
    # print(pure)
    kids = adj[root][:]

    cnt = len(kids)
    for i in kids:
        if pure[i]:
            cnt -= 1
    if cnt == 0:
        print('YES')
        print(root)
        return
    for kid in adj[root]:
        flag = True
        for otherkid in adj[root]:
            if otherkid == kid:
                continue
            if colors[otherkid] != colors[root] or not pure[otherkid]:
                flag = False
                break
        if flag:
            check(kid, root)

main()
if not success:
    print('NO')