gf

include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int, int>pi;

define fi first define se second const int N = 5e5 + 5, mod = 1e9 + 7, i2 = mod + 1 >> 1; int type, n, m, k, sn, fa[20][N], dep[N], c1[N], c2[N], L[N], R[N], b[N << 1]; ll ans, pw[N], inv[N], f[N], f1[4]; bool key[N]; vectorg[N], e[N]; pi w[N]; vectord[N]; void Mul(ll &x, ll y) {

x = x * y % mod; } void Add(ll &x, ll y) {

x = (x + y) % mod; } struct qry {

int l, r, k; }; vectorc[N]; struct sgt {

struct tree {

int l, r;
ll s, mul;

} t[N << 2]; void build(int p, int l, int r) {

t[p] = {l, r, 0, 1};

if (l == r)
    return;

int mid = l + r >> 1;
build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);

} void upd(int p, ll k) {

Mul(t[p].mul, k), Mul(t[p].s, k);

} void down(int p) {

if (t[p].mul != 1)
    upd(p << 1, t[p].mul), upd(p << 1 | 1, t[p].mul), t[p].mul = 1;

} void upd(int p) {

t[p].s = (t[p << 1].s + t[p << 1 | 1].s) % mod;

} void mdf(int p, int l, int r, int k) {

if (t[p].l > r || t[p].r < l)
    return;

if (t[p].l >= l && t[p].r <= r)
    return upd(p, k);

down(p), mdf(p << 1, l, r, k), mdf(p << 1 | 1, l, r, k), upd(p);

} void ins(int p, int x, ll k) {

if (t[p].l > x || t[p].r < x)
    return;

if (t[p].l == t[p].r)
    return t[p].s = k, void();

down(p), ins(p << 1, x, k), ins(p << 1 | 1, x, k), upd(p);

} ll ask(int p, int l, int r) {

if (t[p].l > r || t[p].r < l)
    return 0;

if (t[p].l >= l && t[p].r <= r)
    return t[p].s;

return down(p), (ask(p << 1, l, r) + ask(p << 1 | 1, l, r)) % mod;

} } T, T1; bool in(int x, int y) {

return L[x] <= L[y] && R[x] >= L[y]; } void dfs(int x, int p) {

dep[x] = dep[p] + 1, L[x] = ++sn, fa[0][x] = p;

for (int i = 1; i <= 19; i++)

fa[i][x] = fa[i - 1][fa[i - 1][x]];

for (int y : e[x])

if (y != p)
    dfs(y, x);

R[x] = sn; } int kth(int x, int k) {

for (int i = 0; i <= 19; i++)

if (k >> i & 1)
    x = fa[i][x];

return x; } int lca(int x, int y) {

if (dep[x] < dep[y])

swap(x, y);

for (int i = 19; ~i; i--)

if (dep[x] - dep[y] >= 1 << i)
    x = fa[i][x];

if (x == y)

return x;

for (int i = 19; ~i; i--)

if (fa[i][x]^fa[i][y])
    x = fa[i][x], y = fa[i][y];

return fa[0][x]; } void dfs1(int x, int p) {

for (int y : e[x])

if (y != p)
    dfs1(y, x), c1[x] += c1[y];

for (int y : g[x])

if (in(x, y))
    c1[x]++, c1[kth(y, dep[y] - dep[x] - 1)]++;

} void dfs2(int x, int p) {

for (int y : g[x])

if (!in(x, y))
    c2[x]++;

int s = 0;

for (int y : e[x])

if (y != p)
    s += c1[y];

for (int y : e[x])

if (y != p)
    c2[y] = c2[x] + s - c1[y], dfs2(y, x);

} ll calc(int x, int p) {

if (!d[x].size())

return f1[2];

int ct = 0, w = 0; ll res = 0, s; b[++ct] = L[x] + 1, b[++ct] = R[x] + 1;

for (pi i : d[x])

b[++ct] = L[i.fi], b[++ct] = R[i.fi] + 1, b[++ct] = L[i.se], b[++ct] = R[i.se] + 1;

sort(b + 1, b + ct + 1), ct = unique(b + 1, b + ct + 1) - b - 1, T1.build(1, 1, ct);

for (int i = 1; i <= ct; i++)

c[i].clear();

for (int i = 2; i <= ct; i++)

T1.ins(1, i, T.ask(1, b[i - 1], b[i] - 1));

for (pi i : d[x]) {

int l1 = lower_bound(b + 1, b + ct + 1, L[i.fi]) - b, r1 = lower_bound(b + 1, b + ct + 1, R[i.fi] + 1) - b;
int l2 = lower_bound(b + 1, b + ct + 1, L[i.se]) - b, r2 = lower_bound(b + 1, b + ct + 1, R[i.se] + 1) - b;
c[l1].push_back({l2 + 1, r2, 2}), c[r1].push_back({l2 + 1, r2, i2}), c[l2].push_back({l1 + 1, r1, 2}),
c[r2].push_back({l1 + 1, r1, i2});

}

for (int i = 1; i <= ct; i++) {

if (i > 1)
    Add(res, T.ask(1, b[i - 1], b[i] - 1)*T1.ask(1, 1, ct));

for (qry j : c[i])
    T1.mdf(1, j.l, j.r, j.k);

}

for (int y : e[x])

if (y != p)
    s = T.ask(1, L[y], R[y]), Add(res, -s * s), w += c1[y];

return res * inv[w + 1] % mod; } void solve(int x, int p) {

for (int y : e[x])

if (y != p)
    solve(y, x);

for (int y : g[x])

if (in(x, y))
    T.mdf(1, L[y], R[y], 2);

for (int i = 0; i <= 3; i++)

f1[i] = 0;

f1[0] = 1; ll f2[4] = {0}; int ct = 0;

for (int y : e[x]) {

if (y == p)
    continue;

ct += c1[y];
ll sf = T.ask(1, L[y], R[y]);

for (int i = 0; i <= 3; i++) {
    Add(f2[i], f1[i]*pw[c1[y]]);
    Add(f2[min(i + 1, 3)], f1[i]*sf);
}

for (int i = 0; i <= 3; i++)
    f1[i] = f2[i], f2[i] = 0;

}

for (int y : e[x])

if (y != p)
    T.mdf(1, L[y], R[y], pw[ct - c1[y]]);

if (!key[x])

Add(f[x], f1[2] + f1[3]), Add(ans, (calc(x, p) + f1[3])*pw[c2[x]]);

else

Add(f[x], -f1[0] - f1[1]), Add(ans, (calc(x, p) - f1[2] - f1[1] - f1[0])*pw[c2[x]]);

T.ins(1, L[x], f[x]); } int rd() {

int x = 0; char ch = getchar();

while (ch < '0' || ch > '9')

ch = getchar();

while (ch >= '0' && ch <= '9')

x = (x << 1) + (x << 3) + ch - '0', ch = getchar();

return x; } int main() {

type = rd(), n = rd(), m = rd(), k = rd(), pw[0] = inv[0] = 1;

for (int i = 1; i <= max(n, m); i++)

pw[i] = pw[i - 1] * 2 % mod, inv[i] = inv[i - 1] * i2 % mod;

for (int i = 1, x, y; i < n; i++)

x = rd(), y = rd(), e[x].push_back(y), e[y].push_back(x);

for (int i = 1, x, y; i <= m; i++)

x = rd(), y = rd(), g[x].push_back(y), g[y].push_back(x), w[i] = {x, y};

for (int i = 1; i <= k; i++)

key[rd()] = 1;

dfs(1, 0), dfs1(1, 0), dfs2(1, 0), T.build(1, 1, n);

for (int i = 1; i <= m; i++) {

int x = w[i].fi, y = w[i].se;

if (!in(x, y) && !in(y, x))
    d[lca(x, y)].push_back({x, y});

}

solve(1, 0); printf("%lld", (mod - ans) % mod); }