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

using i64 = long long;
constexpr int N = 6e5 + 5;
constexpr i64 V = 1.1e10, inf = 4e18;

struct Segment {
    i64 k = 0, b = inf;
    i64 operator()(i64 x) const {
        return k * x + b;
    }
};
struct Node;
struct PN {
    int id = 0;
    operator bool() const;
    Node *operator->() const;
};

struct Node {
    PN l, r;
    Segment s;
};
Node pool[N], *ptr = pool;
PN::operator bool() const {
    return id;
}
Node *PN::operator->() const {
    return pool + id;
}
PN newNode() {
    ++ptr;
    *ptr = Node{};
    return PN{int(ptr - pool)};
}

void modify(PN &u, i64 l, i64 r, Segment x) {
    if (!u) {
        u = newNode();
        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(PN &u, PN &v, i64 l, i64 r) {
    if (!v) {
        return;
    }
    if (!u) {
        std::swap(u, 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(PN 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<PN> root(n);
    auto dfs = [&](auto self, int u, int fa) -> void {
        root[u] = PN{};
        for (auto [v, w] : adj[u]) if (v != fa) {
            dep[v] = dep[u] + w;
            self(self, v, u);
            merge(root[u], root[v], -V, V);
        }
        if (root[u]) {
            i64 x = dep[u] + L;
            f[u] = query(root[u], -V, V, x) + x * x;
        } else {
            f[u] = 0;
        }
        modify(root[u], -V, V, Segment{-2 * dep[u], f[u] + dep[u] * dep[u]});
    };

    int q;
    std::cin >> q;

    while (q--) {
        int x;
        std::cin >> x;
        --x;

        ptr = pool;

        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;
}