"""
Tree Racers

Small-to-large. Since k is small, this is fine?
"""
def main():
    n, m, k = map(int, input().split())
    tree = [[] for _ in range(n)]
    for _ in range(1, n):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        tree[u].append(v)
        tree[v].append(u)

    racers = []
    for i in range(m):
        p, t = map(int, input().split())
        p -= 1
        racers.append((p, t))

    root = int(input()) - 1
    is_special = [False for _ in range(n)]
    c = int(input())
    for _ in range(c):
        u = int(input()) - 1
        is_special[u] = True

    depth = [0 for _ in range(n)]
    par = [None for _ in range(n)]
    order = []
    stk = [root]
    while stk:
        u = stk.pop()
        order.append(u)
        for v in tree[u]:
            if v == par[u]:
                continue
            par[v] = u
            depth[v] = depth[u] + 1
            stk.append(v)

    alive_racers = [[] for _ in range(n)]
    for i, (src, _) in enumerate(racers):
        alive_racers[src].append(i)

    def time_to(u):
        def racer_key(idx):
            src, t = racers[idx]
            time = t * (depth[src] - depth[u])
            return (time, t)

        return racer_key

    for u in reversed(order):
        big = None
        for v in tree[u]:
            if v == par[u]:
                continue
            if big is None or len(alive_racers[v]) > len(alive_racers[big]):
                big = v
        if big is not None:
            alive_racers[big], alive_racers[u] = alive_racers[u], alive_racers[big]
        for v in tree[u]:
            if v == par[u]:
                continue
            alive_racers[u] += alive_racers[v]
        if is_special[u]:
            alive_racers[u].sort(key=time_to(u))
            alive_racers[u] = alive_racers[u][:k]

    ans = [-1 for _ in racers]
    for idx in alive_racers[root]:
        src, t = racers[idx]
        ans[idx] = depth[src] * t

    for x in ans:
        print(x)

if __name__ == "__main__":
    main()