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
import io, os
import math
from heapq import *
gcd = math.gcd
sqrt = math.sqrt
def ceil(a,b):
    a=-a
    k=a//b
    k=-k
    return k
# arr=list(map(int, input().split()))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def strinp(testcases):
    k = 5
    if (testcases == -1 or testcases == 1):
        k = 1
    f = str(input())
    f = f[2:len(f) - k]
    return f
def bfs(graph,root_node,no_of_nodes,ignore,colors):
    st=root_node
    n=no_of_nodes
    q=[st] # not really a queue, will use ptr instead to select top of the queue
    ptr=0
    nv=[True]*n # If pt is visited or not
    nv[ignore]=False
    nv[st]=False
    trig=False
    col=colors[st]
    while(ptr!=len(q)):
        child=graph[q[ptr]]
        for i in range(len(child)):
            if(nv[child[i]]):
                if(colors[child[i]]!=col):
                    return False
                nv[child[i]]=False
                q.append(child[i])
        ptr+=1
    return True
def main():
    n=int(input())
    graph=[[] for i in range(n)]
    for i in range(n-1):
        arr=list(map(int, input().split()))
        v=arr[0]-1
        u=arr[1]-1
        graph[v].append(u)
        graph[u].append(v)
    arr=list(map(int, input().split()))
    if(n<=3):
        print("YES")
        exit()
    c1=[]
    c2=[]
    c3=[]
    trig=True
    if(c1==[]):
        c1=[arr[0],1,0]
    for i in range(1,n):
        if(arr[i]==c1[0]):
            c1[1]+=1
        elif(c2!=[] and arr[i]==c2[0]):
            c2[1]+=1
        elif(c3!=[] and arr[i]==c3[0]):
            c3[1]+=1
        elif(c2==[]):
            c2=[arr[i],1,i]
        elif(c3==[]):
            c3=[arr[i],1,i]
        else:
            trig=False
            break
    if(trig==False):
        print("NO")
        exit()
    a=False
    c=[c1,c2,c3]
    for i in range(3):
        if(c[i]!=[] and c[i][1]==1):
            root=c[i][2]
            if(len(graph[root])>2):
                print("NO")
                exit()
            r1=graph[root][0]
            a=a or bfs(graph,r1,n,root,arr)
            if(len(graph[root])==2):
                r2=graph[root]
                a=a or bfs(graph,r2,n,root,arr)
    if(a):
        print("YES")
    else:
        print("NO")
main()