#!/usr/bin/env python3
import sys
import heapq

sys.setrecursionlimit(300000)

MAXN = 200005

n, m, k = map(int, sys.stdin.readline().split())

adj = [[] for _ in range(MAXN)]
sadj = [[] for _ in range(MAXN)]
specialTs = [[] for _ in range(MAXN)]
isSpecial = [False] * MAXN
ts = [-1] * MAXN
depth = [0] * MAXN
ans = [-1] * MAXN

# edges
for _ in range(n - 1):
    a, b = map(int, sys.stdin.readline().split())
    adj[a].append(b)
    adj[b].append(a)

# m pairs (p, t)
tToId = {}
for i in range(m):
    p, t = map(int, sys.stdin.readline().split())
    ts[p] = t
    tToId[t] = i  # same as C++: last one wins if duplicates

# e, c
e_c = []
while len(e_c) < 2:
    e_c += list(map(int, sys.stdin.readline().split()))
e, c = e_c

# c special nodes (may be split across lines)
picked = 0
while picked < c:
    nums = list(map(int, sys.stdin.readline().split()))
    for x in nums:
        isSpecial[x] = True
        picked += 1
        if picked == c:
            break


def dfs(x, p, d, lastSpecial):
    depth[x] = d
    if isSpecial[x] or x == e:
        if x != e:
            # in the C++ flow, lastSpecial is already set to some special (e at root)
            sadj[lastSpecial].append(x)
        lastSpecial = x
    if ts[x] != -1:
        # pair: (acc_value, t)
        specialTs[lastSpecial].append(((d - depth[lastSpecial]) * ts[x], ts[x]))
    for y in adj[x]:
        if y != p:
            dfs(y, x, d + 1, lastSpecial)


def dfsSpecial(x):
    cur = specialTs[x]
    for y in sadj[x]:
        dfsSpecial(y)
        for val, t in specialTs[y]:
            cur.append((val + (depth[y] - depth[x]) * t, t))

    # Keep at most k smallest (by first, then second) for x != e
    # Use a heap of (-first, -second) so that heappop removes the same element
    # C++ priority_queue would remove (largest first, then largest second on ties)
    pq = []
    for val, t in cur:
        heapq.heappush(pq, (-val, -t))
        if x != e and len(pq) > k:
            heapq.heappop(pq)

    cur.clear()
    while pq:
        nv, nt = heapq.heappop(pq)
        cur.append((-nv, -nt))  # back to (first, second)


dfs(e, -1, 0, -1)
dfsSpecial(e)

specialTs[e].sort()  # ascending by (value, then t)
for val, t in specialTs[e]:
    ans[tToId[t]] = val

for i in range(m):
    print(ans[i])