//J逃跑
#include <bits/stdc++.h>

using i64 = long long;
const int MAXN = 100005;
std::vector<int> graph[MAXN];
bool isJumpboard[MAXN];
int depth[MAXN];

// 从node开始深度优先搜索，计算每个节点的期望深度
double dfs(int node, int parent, double prob) {
    double total = 0;
    int jumpCount = isJumpboard[node] ? 1 : 0; // 统计当前节点是否是跳板
    for (int i = 0; i < graph[node].size(); i++) {
        int nextNode = graph[node][i];
        if (nextNode != parent) { // 避免重复访问父节点
            total += dfs(nextNode, node, prob * (1.0 - (jumpCount > 0 ? prob : 0))); // 递归计算子节点的期望深度，如果当前节点是跳板，那么子节点的概率要乘以(1 - prob)
            jumpCount += isJumpboard[nextNode] ? 1 : 0; // 统计子节点是否是跳板
        }
    }
    return total + prob * depth[node]; // 返回当前节点的期望深度，等于子节点的期望深度之和加上当前节点的概率乘以当前节点的深度
}

// 解决问题的主要函数
void solve() {
    int n, m;
    double p;
    std::cin >> n >> m >> p; // 输入n, m, p
    for (int i = 0; i < n - 1; i++) {
        int x, y;
        std::cin >> x >> y; // 输入树的边
        graph[x].push_back(y); // 建立邻接表
        graph[y].push_back(x);
    }
    for (int i = 1; i <= n; i++) {
        depth[i] = graph[i].size() == 1 ? 0 : MAXN; // 初始化每个节点的深度，如果是叶子节点，深度为0，否则为MAXN
    }
    std::vector<int> jumpboards(m);
    for (int i = 0; i < m; i++) {
        std::cin >> jumpboards[i]; // 输入跳板编号
        isJumpboard[jumpboards[i]] = true; // 标记跳板
    }
    for (int i = 0; i < m; i++) {
        int node = jumpboards[i];
        while (node != 1) { // 从每个跳板开始向上更新深度，直到根节点
            node = graph[node][0]; // 取第一个邻居作为父节点（因为是树，所以只有一个父节点）
            depth[node] = std::min(depth[node], depth[graph[node][0]] + 1); // 更新当前节点的深度为父节点的深度加一和原来的深度的较小值
        }
    }
    double answer = dfs(1, 0, p); // 从根节点开始搜索，计算答案
    std::cout << std::fixed << std::setprecision(2) << answer << std::endl; // 输出答案，保留两位小数
}

int main() {
    std::ios::sync_with_stdio(false); // 关闭同步流，提高输入输出效率
    std::cin.tie(nullptr); // 解除cin和cout的绑定，提高输入输出效率
    solve(); // 调用solve()函数解决问题
    return 0;
}