#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using lll = __int128_t;
using ld = double;

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for (int i = 0; i < (n); i += 1)
#define len(a) ((int)(a).size())

mt19937 rnd(234);
const ll inf = 1e18;

struct frac {
    ll a, b;

    frac() {}
    frac(ll a_, ll b_) : a(a_), b(b_) {
        assert(b != 0);
        if (b < 0) {
            a *= -1;
            b *= -1;
        }
    }

    ld get() {
        return ld(a) / b;
    }
};

bool operator<(const frac &fst, const frac &snd) {
    return lll(fst.a) * snd.b < lll(snd.a) * fst.b;
}

bool operator==(const frac &fst, const frac &snd) {
    return !((fst < snd) or (snd < fst));
}

frac operator-(const frac &fst, const frac &snd) {
    return frac{fst.a * snd.b - snd.a * fst.b, fst.b * snd.b};
}

struct vec {
    ll x, y;

    vec() {}
    vec(ll x_, ll y_) : x(x_), y(y_) {}
};

vec operator+(const vec &a, const vec &b) {
    return vec(a.x + b.x, a.y + b.y);
}

vec operator-(const vec &a, const vec &b) {
    return vec(a.x - b.x, a.y - b.y);
}

ll operator*(const vec &a, const vec &b) {
    return a.x * b.x + a.y * b.y;
}

ll operator%(const vec &a, const vec &b) {
    return a.x * b.y - a.y * b.x;
}

frac intersect(vec a, vec b) {
    vec to = a - b;
    assert(to.y != 0);
    if (to.x == 0) {
        return frac{a.x, 1};
    }
    ll numer = a.x * to.y - a.y * to.x;
    ll denum = to.y;
    return frac{numer, denum};
}

pair<frac, frac> get_seg(frac l, frac r, vec a, vec b) {
    if (a.x == b.x and a.y == b.y) {
        return {l, r};
    }
    assert(a.x != b.x or a.y != b.y);
    if (a.y == b.y) {
        if (a.x < b.x) {
            if (a.y >= 0) {
                return {r, l};
            }
        } else {
            if (a.y <= 0) {
                return {r, l};
            }
        }
        return {l, r};
    }
    frac d = intersect(a, b);
    d = max(d, l);
    d = min(d, r);
    if (a.y < b.y) {
        return {l, d};
    } else {
        return {d, r};
    }
}

pair<vec, vec> get_tangent(vector<vec> &a, vector<vec> &b, ll d) {
    int n = len(a);
    int m = len(b);
    pair<vec, vec> opt = {b[0], a[0]};
    auto get_opt = [&](pair<vec, vec> fst, pair<vec, vec> snd) {
        vec bebra = fst.second - fst.first;
        vec aboba = snd.second - snd.first;
        if (bebra % aboba * d > 0) {
            return snd;
        } else {
            return fst;
        }
    };
    rep(i, m) {
        int cur = 0;
        for (int bit = 20; bit >= 0; bit -= 1) {
            int cur1 = ((cur - (1 << bit)) % n + n) % n;
            int cur2 = (cur + (1 << bit)) % n;
            if ((a[cur] - b[i]) % (a[cur1] - b[i]) * d > 0) {
                cur = cur1;
            }
            if ((a[cur] - b[i]) % (a[cur2] - b[i]) * d > 0) {
                cur = cur2;
            }
        }
        opt = get_opt(opt, make_pair(b[i], a[cur]));
    }
    return opt;
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int t;
    cin >> t;
    rep(itr, t) {
        int n;
        ll l_int, r_int;
        cin >> n >> l_int >> r_int;
        frac l{l_int, 1}, r{r_int, 1};
        int k;
        cin >> k;
        vector<vec> star(k);
        rep(i, k) {
            cin >> star[i].x >> star[i].y;
        }
        vector<vector<vec>> moons(n);
        rep(i, n) {
            int ki;
            cin >> ki;
            moons[i].resize(ki);
            rep(j, ki) {
                cin >> moons[i][j].x >> moons[i][j].y;
            }
        }
        vector<pair<frac, frac>> banned;
        banned.emplace_back(frac{l_int - 1, 1}, l);
        banned.emplace_back(r, frac{r_int + 1, 1});
        rep(i, n) {
            pair<vec, vec> fst = get_tangent(star, moons[i], 1);
            pair<vec, vec> snd = get_tangent(star, moons[i], -1);
            auto [l1, r1] = get_seg(l, r, fst.first, fst.second);
            auto [l2, r2] = get_seg(l, r, snd.second, snd.first);
            auto [l3, r3] = get_seg(l, r, fst.first, snd.first);
            frac curl = max({l1, l2, l3});
            frac curr = min({r1, r2, r3});
            if (curl < curr) {
                banned.emplace_back(curl, curr);
            }
        }
        sort(all(banned));
        bool found = false;
        ld result = 0;
        frac mx = l;
        for (int i = 0; i + 1 < len(banned); i += 1) {
            mx = max(mx, banned[i].second);
            frac lft = mx;
            frac rght = banned[i + 1].first;
            if (rght < lft) {
                continue;
            }
            result += rght.get() - lft.get();
            if (lft == rght and (lft == l or rght == r)) {
                continue;
            }
            found = true;
        }
        if (!found) {
            cout << -1 << "\n";
        } else {
            cout << fixed << setprecision(14) << result << "\n";
        }
    }
    return 0;
}