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

class UnionFind:
    def __init__(self, sz):
        self.__ranks   = [1] * sz
        self.__sizes   = [1] * sz
        self.__parents = [ i for i in range(sz) ]

    def find_parent(self, x):
        if x == self.__parents[x]:
            return x
        else:
            self.__parents[x] = self.find_parent( self.__parents[x] )
            return self.__parents[x]

    def same(self, x, y):
        return self.find_parent(x) == self.find_parent(y)

    def unite(self, x, y):
        px = self.find_parent(x)
        py = self.find_parent(y)
        if px == py:
            return
        if self.__ranks[px] > self.__ranks[py]:
            self.__parents[py] = px
            self.__sizes[px] += self.__sizes[py]
        else:
            self.__parents[px] = py
            self.__sizes[py] += self.__sizes[px]
            if self.__ranks[px] == self.__ranks[py]:
                self.__ranks[py] += 1

    def size(self, n):
        return self.__sizes[n]
#### 

def main():
    n = int(input())

    edge = {}
    for i in range(n - 1):
        u,v = map(int, sys.stdin.readline().split())
        if u not in edge:
            edge[u] = []
        if v not in edge:
            edge[v] = []
        edge[u].append(v)
        edge[v].append(u)
    
    colors = [-1] * (n + 1)
    for i,c in enumerate(map(int, sys.stdin.readline().split())):
        colors[i + 1] = c

    uf = UnionFind(n + 1)
    for u in edge.keys():
        for v in edge[u]:
            if colors[u] == colors[v]:
                uf.unite(u,v)

    tree = set()
    for v in range(1,n+1):
        tree.add(uf.find_parent(v))

    target_v = -1
    ok = False
    for u in range(1,n+1):
        cnt = set()
        for v in edge[u]:
            cnt.add(uf.find_parent(v))
        if len(cnt) == len(tree) - (1 if uf.size(u) == 1 else 0):
            ok = True
            target_v = u
            break

    if ok:
        print("YES")
        print(target_v)
    else:
        print("NO")

if __name__ == '__main__':
    main()


