#!/usr/bin/env python3

import sys

def solve():
    n, q, mode = map(int, input().split())
    
    adj = [[] for _ in range(n)]
    for _ in range(n - 1):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        adj[u].append(v)
        adj[v].append(u)
        
    logn = 18
    tin = [0] * n
    tout = [0] * n
    depth = [0] * n
    pai = [[0] * logn for _ in range(n)]
    
    
    def dfs(source):
        nonlocal tin, tout, depth, pai, adj

        dfs_time = -1
        pai[source][0] = source
        stk = [source, source]
        ordem = []

        while stk:
            u = stk.pop()

            if len(stk) == 0 or stk[-1] != u:
                tout[u] = dfs_time
                continue

            for i in range(1, logn):
                pai[u][i] = pai[pai[u][i-1]][i-1]

            dfs_time += 1
            tin[u] = dfs_time
            ordem.append(u)

            for v in adj[u]:
                if v != pai[u][0]:
                    depth[v] = depth[u] + 1
                    pai[v][0] = u
                    stk.append(v)
                    stk.append(v)

    dfs(0)
    
    def upper(a, b):
        return tin[a] <= tin[b] and tout[b] <= tout[a]
        
    def LCA(a, b):
        if upper(a, b): return a
        if upper(b, a): return b
        for i in range(logn - 1, -1, -1):
            if not upper(pai[a][i], b):
                a = pai[a][i]
        return pai[a][0]
        
    def dist(a, b):
        return depth[a] + depth[b] - 2 * depth[LCA(a, b)]
        
    paths = []
    for _ in range(q):
        a, b = map(int, input().split())
        a -= 1
        b -= 1

        if tin[a] > tin[b]:
            a, b = b, a

        lca = LCA(a, b)
        length = dist(a, b)
        paths.append((a, b, lca, length))
        
    # sort paths by: depth[lca] descending, then lca ascending, then length ascending
    paths.sort(key=lambda p: (-depth[p[2]], p[2], p[3]))
    
    bit_tree = [0] * n
    bit_node = [0] * n
    
    def add(bit, i, delta):
        i += 1
        while i -1 < len(bit):
            bit[i - 1] += delta
            i += i & (-i)
            
    def add_range(bit, l, r, delta):
        add(bit, l, delta)
        add(bit, r + 1, -delta)
        
    def query(bit, i):
        i += 1
        ans = 0
        while i > 0:
            ans += bit[i - 1]
            i -= i & (-i)
        return ans
        
    def query_range(bit, l, r):
        return query(bit, r) - query(bit, l - 1)
        
    def solve_node(cur_paths, bit):
        events = []
        for p in cur_paths:
            a, b, lca, length = p
            events.append((tin[a], tin[a], tin[b], 0))
            events.append((tin[a], tout[a], tin[b] - 1, -1))
            events.append((tin[a], tout[a], tout[b], 1))
            
        # sort events: if y is same, sort by abs(t). then by y
        events.sort(key=lambda e: (e[2], abs(e[3])))
        
        ans = 0
        for e in events:
            x1, x2, y, t = e
            if t == 0:
                add(bit, x1, 1)
            else:
                ans += t * query_range(bit, x1, x2)
                
        for p in cur_paths:
            add(bit, tin[p[0]], -1)
            
        return ans - len(cur_paths)
        
    ans = q * (q - 1) // 2
    cur = []
    

    for p in paths:
        a, b, lca, length = p
        ans += query(bit_tree, tin[a]) + query(bit_tree, tin[b]) - query(bit_tree, tin[lca])
        
        add_range(bit_tree, tin[lca], tout[lca], -1)
        if upper(a, b):
            add_range(bit_tree, tin[b], tout[b], 1)
        else:
            if len(cur) > 0 and cur[-1][2] != lca:
                ans += solve_node(cur, bit_node)
                cur = []
            cur.append(p)
            
    ans += solve_node(cur, bit_node)
    
    if mode:
        print(ans)
    else:
        print((1 if ans == q*(q - 1)//2 else 0 ))   

if __name__ == '__main__':
    solve()