include

include

include

include

using namespace std;

const int MOD = 1e9 + 7;

struct Edge {

int u, v;

};

vector adj[105]; int n, m, k; int critical[105]; int parent[105]; int subtree_size[105]; bool is_critical[105]; vector critical_list; vector non_tree_edges; int allowed_count[105]; int intersection_count[105][105]; int power(int base, int exp) {

int result = 1;
while (exp > 0) {
    if (exp % 2 == 1) {
        result = 1LL * result * base % MOD;
    }
    base = 1LL * base * base % MOD;
    exp /= 2;
}
return result;

}

void dfs(int u, int p) {

parent[u] = p;
subtree_size[u] = 1;
for (int v : adj[u]) {
    if (v == p) continue;
    dfs(v, u);
    subtree_size[u] += subtree_size[v];
}

}

bool in_subtree(int u, int v) {

if (u == v) return true;
for (int node = v; node != u; node = parent[node]) {
    if (node == -1) return false;
}
return true;

}

int main() {

int c;
cin >> c;
cin >> n >> m >> k;
for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
}
for (int i = 0; i < m; i++) {
    int a, b;
    cin >> a >> b;
    non_tree_edges.push_back({a, b});
}
for (int i = 0; i < k; i++) {
    cin >> critical[i];
    is_critical[critical[i]] = true;
    critical_list.push_back(critical[i]);
}

memset(parent, -1, sizeof(parent));
dfs(1, -1);

for (auto &e : non_tree_edges) {
    int u = e.u, v = e.v;
    bool u_leaf = (adj[u].size() == 1), v_leaf = (adj[v].size() == 1);
    if (u_leaf && v_leaf) {
        continue;
    }
    vector<int> allowed;
    for (int s : critical_list) {
        if (u_leaf) {
            if (in_subtree(v, s)) {
                allowed.push_back(s);
            }
        } else if (v_leaf) {
            if (in_subtree(u, s)) {
                allowed.push_back(s);
            }
        } else {
            allowed.push_back(s);
        }
    }
    for (int s : allowed) {
        allowed_count[s]++;
    }
}

vector<int> individual(k);
for (int i = 0; i < k; i++) {
    individual[i] = allowed_count[critical_list[i]];
}

int total = 0;
vector<int> power2(n + 1);
for (int i = 0; i <= n; i++) {
    power2[i] = power(2, i);
}

vector<int> sign(k + 1, 1);
for (int i = 1; i <= k; i++) {
    sign[i] = -sign[i - 1];
}

for (int mask = 0; mask < (1 << k); mask++) {
    int bit_count = __builtin_popcount(mask);
    vector<int> current;
    for (int i = 0; i < k; i++) {
        if (mask & (1 << i)) {
            current.push_back(critical_list[i]);
        }
    }
    int cnt = 0;
    for (auto &e : non_tree_edges) {
        int u = e.u, v = e.v;
        bool valid = true;
        for (int s : current) {
            bool ok = false;
            if (in_subtree(u, s) && in_subtree(v, s)) {
                ok = true;
            }
            if (!ok) {
                valid = false;
                break;
            }
        }
        if (valid) {
            cnt++;
        }
    }
    total = (total + sign[bit_count] * power2[cnt] + MOD) % MOD;
}

cout << (total % MOD + MOD) % MOD << endl;
return 0;

}