#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

using F = long double;

struct Pt {
    F s;
    F v;
    int a;
    
    friend auto operator<=>(const Pt &a, const Pt &b) = default;
};

void solve() {
    int N, W, H, Q;
    std::cin >> N >> W >> H >> Q;
    
    std::vector<Pt> p;
    p.push_back({0, 0, -1});
    p.push_back({F(W), 0, 1});
    for (int i = 0; i < N; i++) {
        int x1, x2, y;
        std::cin >> x1 >> x2 >> y;
        
        p.push_back({F(x1) * H / y, F(y - H) / y, 1});
        p.push_back({F(x2) * H / y, F(y - H) / y, -1});
    }
    
    std::sort(p.begin(), p.end());
    
    const int K = p.size();
    std::vector<int> pre(K);
    pre[0] = 1;
    
    F V = 0, S = 0;
    
    auto add = [&](int i, int coef) {
        if (pre[i] == 0) {
            S += (p[i].s - p[i - 1].s) * coef;
            V += (p[i].v - p[i - 1].v) * coef;
        }
    };
    
    for (int i = 0; i < K - 1; i++) {
        pre[i + 1] = pre[i] + p[i].a;
    }
    for (int i = 1; i < K; i++) {
        add(i, 1);
    }
    
    std::vector<int> x(Q);
    for (int i = 0; i < Q; i++) {
        std::cin >> x[i];
    }
    
    std::vector<int> q(Q);
    std::iota(q.begin(), q.end(), 0);
    std::sort(q.begin(), q.end(),
        [&](int i, int j) {
            return x[i] < x[j];
        });
    
    std::priority_queue<std::pair<F, int>, std::vector<std::pair<F, int>>, std::greater<>> pq;
    
    auto getTime = [&](int i) -> F {
        if (p[i - 1].v <= p[i].v) {
            return INFINITY;
        }
        return (p[i].s - p[i - 1].s) / (p[i - 1].v - p[i].v);
    };
    
    auto work = [&](int i) {
        auto t = getTime(i);
        if (t != INFINITY) {
            pq.emplace(t, i);
        }
    };
    
    for (int i = 1; i < K; i++) {
        work(i);
    }
    
    std::vector<F> ans(Q);
    for (auto k : q) {
        while (!pq.empty() && pq.top().first < x[k]) {
            auto [t, i] = pq.top();
            pq.pop();
            
            if (t != getTime(i)) {
                continue;
            }
            
            for (int j = std::max(1, i - 1); j <= std::min(K - 1, i + 1); j++) {
                add(j, -1);
            }
            pre[i] += p[i].a - p[i - 1].a;
            std::swap(p[i - 1], p[i]);
            for (int j = std::max(1, i - 1); j <= std::min(K - 1, i + 1); j++) {
                add(j, 1);
                work(j);
            }
        }
        ans[k] = (S + V * x[k]) / W;
    }
    
    for (int i = 0; i < Q; i++) {
        std::cout << ans[i] << "\n";
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(10);
    
    int t;
    std::cin >> t;
    
    for (int i = 1; i <= t; i++) {
        std::cout << "Case " << i << ":\n";
        solve();
    }
    
    return 0;
}