def count_covered_ranges(N, P, A):
    mod = 10**9 + 7

    def dfs(node, parent_value):
        if P[node] == 0:
            return [A[node]]

        ranges = dfs(P[node], parent_value)
        if A[node] >= parent_value:
            ranges.append(A[node])
        else:
            ranges.extend([A[node], parent_value])

        ranges.sort()
        merged = [ranges[0]]
        for r in ranges[1:]:
            if merged[-1] == r:
                continue
            if merged[-1] + 1 == r:
                merged[-1] = r
            else:
                merged.append(r)

        return merged

    return sum(len(dfs(i, 0)) for i in range(N)) % mod

INFOSYS//Path covered Ranges✅

MOD = 10**9 + 7

def dfs(node, parent, graph, A, subtree_size, unique_count, unique_elements):
    size = 1
    count = {A[node]: 1}
    
    for neighbor in graph[node]:
        if neighbor != parent:
            child_size, child_count = dfs(neighbor, node, graph, A, subtree_size, unique_count, unique_elements)
            size += child_size
            for key, value in child_count.items():
                count[key] = count.get(key, 0) + value
    
    subtree_size[node] = size
    unique_count[node] = count
    unique_elements[node] = len(count)
    return size, count

def GetAnswer(N, M, C, edges, A):
    graph = [[] for _ in range(N)]
    for u, v in edges:
        graph[u - 1].append(v - 1)
        graph[v - 1].append(u - 1)
    
    subtree_size = [0] * N
    unique_count = [{} for _ in range(N)]
    unique_elements = [0] * N

    dfs(0, -1, graph, A, subtree_size, unique_count, unique_elements)
    
    total_unique = unique_elements[0]
    max_satisfaction_sum = total_unique

    for u, v in edges:
        u -= 1
        v -= 1
        
        if subtree_size[u] < subtree_size[v]:
            u, v = v, u
        
        satisfaction_v = unique_elements[v]
        satisfaction_u = total_unique - satisfaction_v
        
        total_satisfaction = (satisfaction_u + satisfaction_v) % MOD
        max_satisfaction_sum = max(max_satisfaction_sum, total_satisfaction)
    
    return max_satisfaction_sum

def main():
    import sys
    input = sys.stdin.read
    data = input().splitlines()
    idx = 0
    N = int(data[idx].strip())
    idx += 1
    M = int(data[idx].strip())
    idx += 1
    C = int(data[idx].strip())
    idx += 1
    edges = []
    for _ in range(M):
        edges.append(list(map(int, data[idx].strip().split())))
        idx += 1
    A = []
    for _ in range(N):
        A.append(int(data[idx].strip()))
        idx += 1
    result = GetAnswer(N, M, C, edges, A)
    print(result)

if __name__ == "__main__":
    main()

crazy rule//infosys

logest palinfrome // infosys