#include <bits/stdc++.h>

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

using F = __float128;
std::istream &operator>>(std::istream &is, F &a) {
    int x;
    is >> x;
    a = x;
    return is;
}
std::ostream &operator<<(std::ostream &is, F a) {
    return is << double(a);
}

template<class T>
struct Point {
    T x;
    T y;
    Point(const T &x_ = 0, const T &y_ = 0) : x(x_), y(y_) {}
    
    template<class U>
    operator Point<U>() {
        return Point<U>(U(x), U(y));
    }
    Point &operator+=(const Point &p) & {
        x += p.x;
        y += p.y;
        return *this;
    }
    Point &operator-=(const Point &p) & {
        x -= p.x;
        y -= p.y;
        return *this;
    }
    Point &operator*=(const T &v) & {
        x *= v;
        y *= v;
        return *this;
    }
    Point &operator/=(const T &v) & {
        x /= v;
        y /= v;
        return *this;
    }
    Point operator-() const {
        return Point(-x, -y);
    }
    friend Point operator+(Point a, const Point &b) {
        return a += b;
    }
    friend Point operator-(Point a, const Point &b) {
        return a -= b;
    }
    friend Point operator*(Point a, const T &b) {
        return a *= b;
    }
    friend Point operator/(Point a, const T &b) {
        return a /= b;
    }
    friend Point operator*(const T &a, Point b) {
        return b *= a;
    }
    friend bool operator==(const Point &a, const Point &b) {
        return a.x == b.x && a.y == b.y;
    }
    friend std::istream &operator>>(std::istream &is, Point &p) {
        return is >> p.x >> p.y;
    }
    friend std::ostream &operator<<(std::ostream &os, const Point &p) {
        return os << "(" << p.x << ", " << p.y << ")";
    }
};

template<class T>
struct Line {
    Point<T> a;
    Point<T> b;
    Line(const Point<T> &a_ = Point<T>(), const Point<T> &b_ = Point<T>()) : a(a_), b(b_) {}
};

template<class T>
T dot(const Point<T> &a, const Point<T> &b) {
    return a.x * b.x + a.y * b.y;
}

template<class T>
T cross(const Point<T> &a, const Point<T> &b) {
    return a.x * b.y - a.y * b.x;
}

template<class T>
T square(const Point<T> &p) {
    return dot(p, p);
}

template<class T>
double length(const Point<T> &p) {
    return std::sqrt(square(p));
}

template<class T>
double length(const Line<T> &l) {
    return length(l.a - l.b);
}

template<class T>
Point<T> normalize(const Point<T> &p) {
    return p / length(p);
}

template<class T>
bool parallel(const Line<T> &l1, const Line<T> &l2) {
    return cross(l1.b - l1.a, l2.b - l2.a) == 0;
}

template<class T>
double distance(const Point<T> &a, const Point<T> &b) {
    return length(a - b);
}

template<class T>
double distancePL(const Point<T> &p, const Line<T> &l) {
    return std::abs(cross(l.a - l.b, l.a - p)) / length(l);
}

template<class T>
double distancePS(const Point<T> &p, const Line<T> &l) {
    if (dot(p - l.a, l.b - l.a) < 0) {
        return distance(p, l.a);
    }
    if (dot(p - l.b, l.a - l.b) < 0) {
        return distance(p, l.b);
    }
    return distancePL(p, l);
}

template<class T>
Point<T> rotate(const Point<T> &a) {
    return Point(-a.y, a.x);
}

template<class T>
int sgn(const Point<T> &a) {
    return a.y > 0 || (a.y == 0 && a.x > 0) ? 1 : -1;
}

template<class T>
bool pointOnLineLeft(const Point<T> &p, const Line<T> &l) {
    return cross(l.b - l.a, p - l.a) > 0;
}

template<class T>
Point<T> lineIntersection(const Line<T> &l1, const Line<T> &l2) {
    return l1.a + (l1.b - l1.a) * (cross(l2.b - l2.a, l1.a - l2.a) / cross(l2.b - l2.a, l1.a - l1.b));
}

template<class T>
bool pointOnSegment(const Point<T> &p, const Line<T> &l) {
    return cross(p - l.a, l.b - l.a) == 0 && std::min(l.a.x, l.b.x) <= p.x && p.x <= std::max(l.a.x, l.b.x)
        && std::min(l.a.y, l.b.y) <= p.y && p.y <= std::max(l.a.y, l.b.y);
}

template<class T>
bool pointInPolygon(const Point<T> &a, const std::vector<Point<T>> &p) {
    int n = p.size();
    for (int i = 0; i < n; i++) {
        if (pointOnSegment(a, Line(p[i], p[(i + 1) % n]))) {
            return true;
        }
    }
    
    int t = 0;
    for (int i = 0; i < n; i++) {
        auto u = p[i];
        auto v = p[(i + 1) % n];
        if (u.x < a.x && v.x >= a.x && pointOnLineLeft(a, Line(v, u))) {
            t ^= 1;
        }
        if (u.x >= a.x && v.x < a.x && pointOnLineLeft(a, Line(u, v))) {
            t ^= 1;
        }
    }
    
    return t == 1;
}

// 0 : not intersect
// 1 : strictly intersect
// 2 : overlap
// 3 : intersect at endpoint
template<class T>
std::tuple<int, Point<T>, Point<T>> segmentIntersection(const Line<T> &l1, const Line<T> &l2) {
    if (std::max(l1.a.x, l1.b.x) < std::min(l2.a.x, l2.b.x)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::min(l1.a.x, l1.b.x) > std::max(l2.a.x, l2.b.x)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::max(l1.a.y, l1.b.y) < std::min(l2.a.y, l2.b.y)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (std::min(l1.a.y, l1.b.y) > std::max(l2.a.y, l2.b.y)) {
        return {0, Point<T>(), Point<T>()};
    }
    if (cross(l1.b - l1.a, l2.b - l2.a) == 0) {
        if (cross(l1.b - l1.a, l2.a - l1.a) != 0) {
            return {0, Point<T>(), Point<T>()};
        } else {
            auto maxx1 = std::max(l1.a.x, l1.b.x);
            auto minx1 = std::min(l1.a.x, l1.b.x);
            auto maxy1 = std::max(l1.a.y, l1.b.y);
            auto miny1 = std::min(l1.a.y, l1.b.y);
            auto maxx2 = std::max(l2.a.x, l2.b.x);
            auto minx2 = std::min(l2.a.x, l2.b.x);
            auto maxy2 = std::max(l2.a.y, l2.b.y);
            auto miny2 = std::min(l2.a.y, l2.b.y);
            Point<T> p1(std::max(minx1, minx2), std::max(miny1, miny2));
            Point<T> p2(std::min(maxx1, maxx2), std::min(maxy1, maxy2));
            if (!pointOnSegment(p1, l1)) {
                std::swap(p1.y, p2.y);
            }
            if (p1 == p2) {
                return {3, p1, p2};
            } else {
                return {2, p1, p2};
            }
        }
    }
    auto cp1 = cross(l2.a - l1.a, l2.b - l1.a);
    auto cp2 = cross(l2.a - l1.b, l2.b - l1.b);
    auto cp3 = cross(l1.a - l2.a, l1.b - l2.a);
    auto cp4 = cross(l1.a - l2.b, l1.b - l2.b);
    
    if ((cp1 > 0 && cp2 > 0) || (cp1 < 0 && cp2 < 0) || (cp3 > 0 && cp4 > 0) || (cp3 < 0 && cp4 < 0)) {
        return {0, Point<T>(), Point<T>()};
    }
    
    Point p = lineIntersection(l1, l2);
    if (cp1 != 0 && cp2 != 0 && cp3 != 0 && cp4 != 0) {
        return {1, p, p};
    } else {
        return {3, p, p};
    }
}

template<class T>
double distanceSS(const Line<T> &l1, const Line<T> &l2) {
    if (std::get<0>(segmentIntersection(l1, l2)) != 0) {
        return 0.0;
    }
    return std::min({distancePS(l1.a, l2), distancePS(l1.b, l2), distancePS(l2.a, l1), distancePS(l2.b, l1)});
}

template<class T>
bool segmentInPolygon(const Line<T> &l, const std::vector<Point<T>> &p) {
    int n = p.size();
    if (!pointInPolygon(l.a, p)) {
        return false;
    }
    if (!pointInPolygon(l.b, p)) {
        return false;
    }
    for (int i = 0; i < n; i++) {
        auto u = p[i];
        auto v = p[(i + 1) % n];
        auto w = p[(i + 2) % n];
        auto [t, p1, p2] = segmentIntersection(l, Line(u, v));
        
        if (t == 1) {
            return false;
        }
        if (t == 0) {
            continue;
        }
        if (t == 2) {
            if (pointOnSegment(v, l) && v != l.a && v != l.b) {
                if (cross(v - u, w - v) > 0) {
                    return false;
                }
            }
        } else {
            if (p1 != u && p1 != v) {
                if (pointOnLineLeft(l.a, Line(v, u))
                    || pointOnLineLeft(l.b, Line(v, u))) {
                    return false;
                }
            } else if (p1 == v) {
                if (l.a == v) {
                    if (pointOnLineLeft(u, l)) {
                        if (pointOnLineLeft(w, l)
                            && pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, l)
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                } else if (l.b == v) {
                    if (pointOnLineLeft(u, Line(l.b, l.a))) {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            && pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                } else {
                    if (pointOnLineLeft(u, l)) {
                        if (pointOnLineLeft(w, Line(l.b, l.a))
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    } else {
                        if (pointOnLineLeft(w, l)
                            || pointOnLineLeft(w, Line(u, v))) {
                            return false;
                        }
                    }
                }
            }
        }
    }
    return true;
}

template<class T>
std::vector<Point<T>> hp(std::vector<Line<T>> lines) {
    std::sort(lines.begin(), lines.end(), [&](auto l1, auto l2) {
        auto d1 = l1.b - l1.a;
        auto d2 = l2.b - l2.a;
        
        if (sgn(d1) != sgn(d2)) {
            return sgn(d1) == 1;
        }
        
        return cross(d1, d2) > 0;
    });
    
    std::deque<Line<T>> ls;
    std::deque<Point<T>> ps;
    for (auto l : lines) {
        if (ls.empty()) {
            ls.push_back(l);
            continue;
        }
        
        while (!ps.empty() && !pointOnLineLeft(ps.back(), l)) {
            ps.pop_back();
            ls.pop_back();
        }
        
        while (!ps.empty() && !pointOnLineLeft(ps[0], l)) {
            ps.pop_front();
            ls.pop_front();
        }
        
        if (cross(l.b - l.a, ls.back().b - ls.back().a) == 0) {
            if (dot(l.b - l.a, ls.back().b - ls.back().a) > 0) {
                
                if (!pointOnLineLeft(ls.back().a, l)) {
                    assert(ls.size() == 1);
                    ls[0] = l;
                }
                continue;
            }
            return {};
        }
        
        ps.push_back(lineIntersection(ls.back(), l));
        ls.push_back(l);
    }
    
    while (!ps.empty() && !pointOnLineLeft(ps.back(), ls[0])) {
        ps.pop_back();
        ls.pop_back();
    }
    if (ls.size() <= 2) {
        return {};
    }
    ps.push_back(lineIntersection(ls[0], ls.back()));
    
    return std::vector(ps.begin(), ps.end());
}

using Pt = Point<F>;
using C = std::complex<F>;

constexpr F eps = 1E-10;

void solve() {
    Pt o;
    F zo;
    Pt v;
    
    std::cin >> o >> zo >> v;
    
    int n1;
    F z1;
    std::cin >> n1 >> z1;
    
    std::vector<Pt> a(n1);
    for (int i = 0; i < n1; i++) {
        std::cin >> a[i];
        a[i] -= o;
    }
    
    int n2;
    F z2;
    std::cin >> n2 >> z2;
    
    std::vector<Pt> b(n2);
    for (int i = 0; i < n2; i++) {
        std::cin >> b[i];
        b[i] -= o;
    }
    for (int i = 0; i < n1; i++) {
        a[i] *= zo - z2;
    }
    for (int i = 0; i < n2; i++) {
        b[i] *= zo - z1;
    }
    
    v *= (z2 - z1);
    
    F mul = 1;
    {
        mul = dot(v, v);
        C rot = C(0, 1) / C(v.x, v.y);
        for (int i = 0; i < n1; i++) {
            auto c = C(a[i].x, a[i].y) * rot;
            a[i] = Pt(c.real(), c.imag());
        }
        for (int i = 0; i < n2; i++) {
            auto c = C(b[i].x, b[i].y) * rot;
            b[i] = Pt(c.real(), c.imag());
        }
    }
    mul /= 2;
    mul *= zo / (zo - z1) / (zo - z2);
    mul *= zo / (zo - z1) / (zo - z2);
    
    // for (int i = 0; i < n1; i++) {
    //     std::cerr << a[i] << "\n";
    // }
    // for (int i = 0; i < n2; i++) {
    //     std::cerr << b[i] << "\n";
    // }
    // std::cerr << "mul : " << mul << "\n";
    
    std::vector<F> xs;
    
    for (int i = 0; i < n1; i++) {
        xs.push_back(a[i].x);
    }
    for (int i = 0; i < n2; i++) {
        xs.push_back(b[i].x);
    }
    
    std::sort(xs.begin(), xs.end());
    {
        auto vv = std::move(xs);
        for (auto v : vv) {
            if (xs.empty() || v - eps > xs.back()) {
                xs.push_back(v);
            }
        }
    }
    
    int m = xs.size();
    std::vector<std::vector<std::array<F, 3>>> la(m), lb(m);
    
    for (int i = 0; i < n1; i++) {
        auto [x1, y1] = a[i];
        auto [x2, y2] = a[(i + 1) % n1];
        int u = std::lower_bound(xs.begin(), xs.end(), x1 - eps) - xs.begin();
        int v = std::lower_bound(xs.begin(), xs.end(), x2 - eps) - xs.begin();
        F coef = -1;
        if (u > v) {
            std::swap(u, v);
            coef *= -1;
        }
        for (int j = u; j < v; j++) {
            // assert(std::min(x1, x2) <= xs[j] && xs[j + 1] <= std::max(x1, x2));
            F yl = (y1 * (x2 - xs[j]) + y2 * (xs[j] - x1)) / (x2 - x1);
            F yr = (y1 * (x2 - xs[j + 1]) + y2 * (xs[j + 1] - x1)) / (x2 - x1);
            la[j].push_back({yl, yr, coef});
        }
    }
    for (int i = 0; i < n2; i++) {
        auto [x1, y1] = b[i];
        auto [x2, y2] = b[(i + 1) % n2];
        int u = std::lower_bound(xs.begin(), xs.end(), x1 - eps) - xs.begin();
        int v = std::lower_bound(xs.begin(), xs.end(), x2 - eps) - xs.begin();
        F coef = -1;
        if (u > v) {
            std::swap(u, v);
            coef *= -1;
        }
        for (int j = u; j < v; j++) {
            // assert(std::min(x1, x2) <= xs[j] && xs[j + 1] <= std::max(x1, x2));
            F yl = (y1 * (x2 - xs[j]) + y2 * (xs[j] - x1)) / (x2 - x1);
            F yr = (y1 * (x2 - xs[j + 1]) + y2 * (xs[j + 1] - x1)) / (x2 - x1);
            lb[j].push_back({yl, yr, coef});
        }
    }
    
    std::vector<std::array<F, 4>> events;
    events.push_back({-1, 0, 0, 0});
    events.push_back({1001, 0, 0, 0});
    
    std::vector<std::array<F, 5>> extra;
    
    for (int i = 0; i < m - 1; i++) {
        F x = xs[i + 1] - xs[i];
        // std::cerr << la[i].size() << " " << lb[i].size() << "\n";
        // std::cerr << "xl : " << xs[i] << ", xr : " << xs[i + 1] << "\n";
        for (auto [yla, yra, ca] : la[i]) {
            for (auto [ylb, yrb, cb] : lb[i]) {
                [&, yla, yra, ca, ylb, yrb, cb]() mutable {
                    // std::cerr << yla << " " << yra << " " << ylb << " " << yrb << "\n";
                    if (ylb - yla > yrb - yra) {
                        std::swap(yla, yra);
                        std::swap(ylb, yrb);
                    }
                    F tl = ylb - yla;
                    F tr = yrb - yra;
                    
                    F lst[4] {-1};
                    F coef = ca * cb;
                    auto add = [&](F r, F c0, F c1, F c2) {
                        r = std::min(r, F(1001));
                        c0 *= coef;
                        c1 *= coef;
                        c2 *= coef;
                        if (lst[0] >= r) {
                            return;
                        }
                        // if (c2) {
                        //     extra.push_back({lst[0], r, c0 - lst[1], c1 - lst[2], c2 - lst[3]});
                        //     events.push_back({lst[0], 0, 0, 0});
                        //     lst[0] = r;
                        //     return;
                        // }
                        events.push_back({lst[0], c0 - lst[1], c1 - lst[2], c2 - lst[3]});
                        lst[0] = r;
                        lst[1] = c0;
                        lst[2] = c1;
                        lst[3] = c2;
                    };
                    add(tl, (yla + yra) * x, x * 2, 0);
                    // std::cerr << "tl : " << tl << ", tr : " << tr << "\n";
                    if (tl + eps < tr) {
                        F dt = tr - tl;
                        F c = x / dt / dt;
                        F c0 = c * (ylb * -tl * (2 * tr - tl) + yrb * tl * tl + yla * tr * tr + yra * tr * (tr - 2 * tl));
                        F c1 = c * 2 * (ylb * tr - yrb * tl - yla * tr + yra * tl + tr * dt);
                        F c2 = c * -dt;
                        // std::cerr << c0 << " " << c1 << " " << c2 << "\n";
                        // {
                        //     // std::cerr << c0 + c1 * tl + c2 * tl * tl << " " << (yla + yra) * x + x * tl * 2 << "\n";
                        //     assert(std::abs<double>((c0 + c1 * tl + c2 * tl * tl) - ((yla + yra) * x + x * tl * 2)) < eps + 1E-8);
                        //     // std::cerr << c0 + c1 * tr + c2 * tr * tr << " " << (ylb + yrb) * x << "\n";
                        //     assert(std::abs<double>((c0 + c1 * tr + c2 * tr * tr) - ((ylb + yrb) * x)) < eps + 1E-8);
                        //     F tm = (tl + tr) / 2;
                        //     // std::cerr << c0 + c1 * tm + c2 * tm * tm << " " << (ylb + (ylb + yrb) / 2) * x / 2 + ((yla + yra) / 2 + yra) * x / 2 + x * tm << "\n";
                        //     assert(std::abs<double>((c0 + c1 * tm + c2 * tm * tm) - ((ylb + (ylb + yrb) / 2) * x / 2 + ((yla + yra) / 2 + yra) * x / 2 + x * tm)) < eps + 1E-8);
                        // }
                        add(tr, c0, c1, c2);
                    }
                    add(F(1001), (ylb + yrb) * x, 0, 0);
                } ();
            }
        }
    }
    
    std::sort(events.begin(), events.end());
    for (int i = 1; i < events.size(); i++) {
        events[i][1] += events[i - 1][1];
        events[i][2] += events[i - 1][2];
        events[i][3] += events[i - 1][3];
    }
    for (auto [l, r, c0, c1, c2] : extra) {
        int u = std::upper_bound(events.begin(), events.end(), std::array<F, 4>{l + eps, INFINITY, INFINITY, INFINITY}) - events.begin() - 1;
        int v = std::upper_bound(events.begin(), events.end(), std::array<F, 4>{r + eps, INFINITY, INFINITY, INFINITY}) - events.begin() - 1;
        for (int i = u; i < v; i++) {
            events[i][1] += c0;
            events[i][2] += c1;
            events[i][3] += c2;
        }
    }
    // for (auto [a, b, c, d] : events) {
    //     std::cerr << a << " " << b << " " << c << " " << d << "\n";
    // }
    std::vector<F> sum(events.size());
    for (int i = 0; i < events.size() - 1; i++) {
        auto [xl, c0, c1, c2] = events[i];
        auto xr = events[i + 1][0];
        sum[i + 1] = sum[i] + (xr - xl) * (c0 + c1 * (xl + xr) / 2 + c2 * (xr * xr + xl * xr + xl * xl) / 3);
    }
    // for (int i = 0; i < events.size(); i++) {
    //     auto [a, b, c, d] = events[i];
    //     std::cerr << a << " " << b << " " << c << " " << d << "\n";
    // }
    // for (int i = 0; i < events.size() - 1; i++) {
    //     F cl, cr;
    //     F x = events[i + 1][0];
    //     {
    //         auto [_, c0, c1, c2] = events[i];
    //         cl = c0 + c1 * x + c2 * x * x;
    //     }
    //     {
    //         auto [_, c0, c1, c2] = events[i + 1];
    //         cr = c0 + c1 * x + c2 * x * x;
    //     }
    //     std::cerr << x << " " << cl << " " << cr << "\n";
    // }
    
    int q;
    std::cin >> q;
    
    for (int i = 0; i < q; i++) {
        int t1, t2;
        std::cin >> t1 >> t2;
        
        int u = std::upper_bound(events.begin(), events.end(), std::array<F, 4>{t1 + eps, INFINITY, INFINITY, INFINITY}) - events.begin() - 1;
        int v = std::upper_bound(events.begin(), events.end(), std::array<F, 4>{t2 + eps, INFINITY, INFINITY, INFINITY}) - events.begin() - 1;
        
        F ans = 0;
        if (t1 == t2) {
            auto [t, c0, c1, c2] = events[u];
            ans = ((c2 * t1) + c1) * t1 + c0;
        } else {
            ans = sum[v] - sum[u];
            // std::cerr << u << " " << v << " " << events[u][0] << " " << events[v][0] << " " << ans << " ";
            {
                auto [xl, c0, c1, c2] = events[u];
                auto xr = t1;
                ans -= (xr - xl) * (c0 + c1 * (xl + xr) / 2 + c2 * (xr * xr + xl * xr + xl * xl) / 3);
            }
            // std::cerr << ans << " ";
            {
                auto [xl, c0, c1, c2] = events[v];
                auto xr = t2;
                ans += (xr - xl) * (c0 + c1 * (xl + xr) / 2 + c2 * (xr * xr + xl * xr + xl * xl) / 3);
            }
            ans /= t2 - t1;
        }
        ans *= mul;
        std::cout << double(ans) << "\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;
    
    while (T--) {
        solve();
    }
    
    return 0;
}