/* f.cpp */
#include <bits/stdc++.h>

using i64 = long long;
constexpr i64 V = 1.1e10, inf = 2e18;

struct Segment {
    i64 k = 0, b = inf;
    i64 operator()(i64 x) const {
        return k * x + b;
    }
};

struct Node {
    Node *l = nullptr, *r = nullptr;
    Segment s;
};
void modify(Node *&u, i64 l, i64 r, Segment x) {
    if (!u) {
        u = new Node{};
        u->s = x;
        return;
    }
    i64 m = (l + r) / 2;
    if (x(m) <= u->s(m)) {
        std::swap(x, u->s);
    }
    if (r - l == 1) {
        return;
    }
    if (x(l) <= u->s(l)) {
        modify(u->l, l, m, x);
    } else if (x(r - 1) <= u->s(r - 1)) {
        modify(u->r, m, r, x);
    }
}
void merge(Node *&u, Node *v, i64 l, i64 r) {
    if (!u) {
        u = v;
        return;
    }
    if (!v) {
        return;
    }
    modify(u, l, r, v->s);
    if (r - l == 1) {
        return;
    }
    i64 m = (l + r) / 2;
    merge(u->l, v->l, l, m);
    merge(u->r, v->r, m, r);
}
i64 query(Node *u, i64 l, i64 r, i64 p) {
    if (!u) {
        return inf;
    }
    i64 m = (l + r) / 2;
    if (p < m) {
        return std::min(u->s(p), query(u->l, l, m, p));
    } else {
        return std::min(u->s(p), query(u->r, m, r, p));
    }
}

void solve() {
    int n, L;
    std::cin >> n >> L;

    std::vector<std::vector<std::pair<int, int>>> adj(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v, w;
        std::cin >> u >> v >> w;
        --u, --v;
        adj[u].emplace_back(v, w), adj[v].emplace_back(u, w);
    }

    std::vector<i64> dep(n), f(n);
    std::vector<Node *> root(n);
    auto dfs = [&](auto self, int u, int fa) -> void {
        root[u] = nullptr;
        for (auto [v, w] : adj[u]) if (v != fa) {
            dep[v] = dep[u] + w;
            self(self, v, u);
            merge(root[u], root[v], 0, V);
        }
        if (root[u]) {
            f[u] = query(root[u], 0, V, dep[u] + L) + (dep[u] + L) * (dep[u] + L);
        } else {
            f[u] = 0;
        }
        modify(root[u], 0, V, Segment{-2 * dep[u], f[u] + dep[u] * dep[u]});
    };

    int q;
    std::cin >> q;

    while (q--) {
        int x;
        std::cin >> x;
        --x;
        dep[x] = 0;
        dfs(dfs, x, -1);
        std::cout << f[x] << '\n';
    }
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}