#include <bits/stdc++.h>
using namespace std;
 
// Holi c:
 
//#define ll long long int
#define ii __int128
#define fi first
#define se second
#define pb push_back
#define all(v) v.begin(), v.end()

typedef long long int ll; 
 
const int Inf = 2e9;
const int Inf2 = 2e9 + 1;
const ll mod = 1e9+7;
const ll INF = 4e18;
const ll INF2 = 1e10 + 1;
 
using ld = long double;

const ld eps = 1e-9, inf = numeric_limits<ld>::max(), pi = acos(-1);

bool geq(ld a, ld b){return a-b >= -eps;}     
bool leq(ld a, ld b){return b-a >= -eps;}     
bool ge(ld a, ld b){return a-b > eps;}        
bool le(ld a, ld b){return b-a > eps;}       
bool eq(ld a, ld b){return abs(a-b) <= eps;}
bool neq(ld a, ld b){return abs(a-b) > eps;} 

struct fraccion{
	ll num, den;
	fraccion(){
		num = 0, den = 1;
	}
	fraccion(ll x, ll y){
		if(y < 0)
			x *= -1, y *=-1;
		ll d = __gcd(abs(x), abs(y));
		num = x/d, den = y/d;
	}
	fraccion(ll v){
		num = v;
		den = 1;
	}
	fraccion operator+(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return fraccion(num*(f.den/d) + f.num*(den/d), den*(f.den/d));
	}
	fraccion operator-() const{
		return fraccion(-num, den);
	}
	fraccion operator-(const fraccion& f) const{
		return *this + (-f);
	}
	fraccion operator*(const fraccion& f) const{
		return fraccion(num*f.num, den*f.den);
	}
	fraccion operator/(const fraccion& f) const{
		return fraccion(num*f.den, den*f.num);
	}
	fraccion operator+=(const fraccion& f){
		*this = *this + f;
		return *this;
	}
	fraccion operator-=(const fraccion& f){
		*this = *this - f;
		return *this;
	}
	fraccion operator++(int xd){
		*this = *this + 1;
		return *this;
	}
	fraccion operator--(int xd){
		*this = *this - 1;
		return *this;
	}
	fraccion operator*=(const fraccion& f){
		*this = *this * f;
		return *this;
	}
	fraccion operator/=(const fraccion& f){
		*this = *this / f;
		return *this;
	}
	bool operator==(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) == (ii)((ii)den/d)*f.num);
	}
	bool operator!=(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) != (ii)((ii)den/d)*f.num);
	}
	bool operator >(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) > (ii)((ii)den/d)*f.num);
	}
	bool operator <(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) < (ii)((ii)den/d)*f.num);
	}
	bool operator >=(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) >= (ii)((ii)den/d)*f.num);
	}
	bool operator <=(const fraccion& f) const{
		ll d = __gcd(den, f.den);
		return (ii)((ii)num*(f.den/d) <= (ii)((ii)den/d)*f.num);
	}
	fraccion inverso() const{
		return fraccion(den, num);
	}
	fraccion fabs() const{
		fraccion nueva;
		nueva.num = abs(num);
		nueva.den = den;
		return nueva;
	}
	long double value() const{
		return (long double)num / (long double)den;
	}
};

bool geqf(fraccion a, fraccion b){return a >= b;}
bool leqf(fraccion a, fraccion b){return a <= b;}
bool gef(fraccion a, fraccion b){return a > b;}
bool lef(fraccion a, fraccion b){return a < b;}
bool eqf(fraccion a, fraccion b){return a == b;}
bool neqf(fraccion a, fraccion b){return a != b;}

struct point{
	ld x, y;
	point(): x(0), y(0){}
	point(ld x, ld y): x(x), y(y){}

	point operator+(const point & p) const{return point(x + p.x, y + p.y);}
	point operator-(const point & p) const{return point(x - p.x, y - p.y);}
	point operator*(const ld & k) const{return point(x * k, y * k);}
	point operator/(const ld & k) const{return point(x / k, y / k);}

	point perp() const{return point(-y, x);}
	ld dot(const point & p) const{return x * p.x + y * p.y;}
	ld cross(const point & p) const{return x * p.y - y * p.x;}
	ld norm() const{return x * x + y * y;}
	ld length() const{return sqrtl(x * x + y * y);}
	point unit() const{return (*this) / length();}

	bool operator==(const point & p) const{return eq(x, p.x) && eq(y, p.y);}
	bool operator!=(const point & p) const{return !(*this == p);}
	bool operator<(const point & p) const{return le(x, p.x) || (eq(x, p.x) && le(y, p.y));}
	bool operator>(const point & p) const{return ge(x, p.x) || (eq(x, p.x) && ge(y, p.y));}
};

istream &operator>>(istream &is, point & p){return is >> p.x >> p.y;}
ostream &operator<<(ostream &os, const point & p){return os << "(" << p.x << ", " << p.y << ")";}

struct pointf {
    fraccion x, y;
    pointf(): x(fraccion()), y(fraccion()) {}
    pointf(fraccion x, fraccion y): x(x), y(y) {}

    pointf operator+(const pointf & p) const{return pointf(x + p.x, y + p.y);}
    pointf operator-(const pointf & p) const{return pointf(x - p.x, y - p.y);}
    pointf operator*(const fraccion & k) const{return pointf(x * k, y * k);}
    pointf operator/(const fraccion & k) const{return pointf(x / k, y / k);}
    
    pointf operator+=(const pointf & p){*this = *this + p; return *this;}
    pointf operator-=(const pointf & p){*this = *this - p; return *this;}
    pointf operator*=(const fraccion & p){*this = *this * p; return *this;}
    pointf operator/=(const fraccion & p){*this = *this / p; return *this;}

    fraccion dot(const pointf & p) const{return x * p.x + y * p.y;}
    fraccion cross(const pointf & p) const{return x * p.y - y * p.x;}
    fraccion norm() const{return x + y;}

    bool operator==(const pointf & p) const{return eqf(x, p.x) && eqf(y, p.y);}
    bool operator!=(const pointf & p) const{return !(*this == p);}
    bool operator<(const pointf & p) const{return lef(x, p.x) || (eqf(x, p.x) && lef(y, p.y));}
    bool operator>(const pointf & p) const{return gef(x, p.x) || (eqf(x, p.x) && gef(y, p.y));}
};

int sgn(ld x){
	if(ge(x, 0)) return 1;
	if(le(x, 0)) return -1;
	return 0;
}

vector<point> convexHull(vector<point> P){
	sort(P.begin(), P.end());
	vector<point> L, U;
	for(int i = 0; i < P.size(); i++){
		while(L.size() >= 2 && leq((L[L.size() - 2] - P[i]).cross(L[L.size() - 1] - P[i]), 0)){
			L.pop_back();
		}
		L.push_back(P[i]);
	}
	for(int i = P.size() - 1; i >= 0; i--){
		while(U.size() >= 2 && leq((U[U.size() - 2] - P[i]).cross(U[U.size() - 1] - P[i]), 0)){
			U.pop_back();
		}
		U.push_back(P[i]);
	}
	L.pop_back();
	U.pop_back();
	L.insert(L.end(), U.begin(), U.end());
	return L;
}

vector<vector<point>> twoSidesCH(vector<point> P){
	sort(P.begin(), P.end());
	vector<vector<point>> L;
	vector<point> U;
	for(int i = 0; i < P.size(); i++){
		while(U.size() >= 2 && leq((U[U.size() - 2] - P[i]).cross(U[U.size() - 1] - P[i]), 0)){
			U.pop_back();
		}
		U.push_back(P[i]);
	}
	if(eq(U[U.size() - 1].x, U[U.size() - 2].x)) U.pop_back();
	L.pb(U);
	U.clear();
	for(int i = P.size() - 1; i >= 0; i--){
		while(U.size() >= 2 && leq((U[U.size() - 2] - P[i]).cross(U[U.size() - 1] - P[i]), 0)){
			U.pop_back();
		}
		U.push_back(P[i]);
	}
	reverse(all(U));
	if(eq(U[U.size() - 1].x, U[U.size() - 2].x)) U.pop_back();
	reverse(all(U));
	if(eq(U[U.size() - 1].x, U[U.size() - 2].x)) U.pop_back();
	L.pb(U);
	return L;
}

ld area(vector<point> & P){
	int n = P.size();
	ld ans = 0;
	for(int i = 0; i < n; i++){
		ans += P[i].cross(P[(i + 1) % n]);
	}
	return abs(ans / 2);
}

pointf intersectLinesf(const point & a1, const point & v1, const point & a2, const point & v2){
	fraccion det = v1.cross(v2);
	pointf b1(a1.x, a1.y), u1(v1.x, v1.y), b2(a2.x, a2.y), u2(v2.x, v2.y);
	return b1 + u1 * ((b2 - b1).cross(u2) / det);
}

point intersectLines(const point & a1, const point & v1, const point & a2, const point & v2){
	//lines a1+tv1, a2+tv2
	//assuming that they intersect
	ld det = v1.cross(v2);
	return a1 + v1 * ((a2 - a1).cross(v2) / det);
}

bool pointInLine(const point & a, const point & v, const point & p){
	return eq((p - a).cross(v), 0);
}

bool pointInSegment(const point & a, const point & b, const point & p){
	return pointInLine(a, b - a, p) && leq((a - p).dot(b - p), 0);
}

int intersectSegmentsInfo(const point & a, const point & b, const point & c, const point & d){
	//segment ab, segment cd
	point v1 = b - a, v2 = d - c;
	int t = sgn(v1.cross(c - a)), u = sgn(v1.cross(d - a));
	if(t == u){
		if(t == 0){
			if(pointInSegment(a, b, c) || pointInSegment(a, b, d) || pointInSegment(c, d, a) || pointInSegment(c, d, b)){
				return -1; //infinity points
			}else{
				return 0; //no point
			}
		}else{
			return 0; //no point
		}
	}else{
		return sgn(v2.cross(a - c)) != sgn(v2.cross(b - c)); //1: single point, 0: no point
	}
}

bool pointInPerimeter(const vector<point> & P, const point & p){
	int n = P.size();
	for(int i = 0; i < n; i++){
		if(pointInSegment(P[i], P[(i + 1) % n], p)){
			return true;
		}
	}
	return false;
}

bool crossesRay(const point & a, const point & b, const point & p){
	return (geq(b.y, p.y) - geq(a.y, p.y)) * sgn((a - p).cross(b - p)) > 0;
}

int pointInPolygon(const vector<point> & P, const point & p){
	if(pointInPerimeter(P, p)){
		return 1;
	}
	int n = P.size();
	int rays = 0;
	for(int i = 0; i < n; i++){
		rays += crossesRay(P[i], P[(i + 1) % n], p);
	}
	return rays & 1;
}

int intersectLineSegmentInfo(const point & a, const point & v, const point & c, const point & d){
	//line a+tv, segment cd
	point v2 = d - c;
	ld det = v.cross(v2);
	if(eq(det, 0)){
		if(eq((c - a).cross(v), 0)){
			return -1; //infinity points
		}else{
			return 0; //no point
		}
	}else{
		return sgn(v.cross(c - a)) != sgn(v.cross(d - a)); //1: single point, 0: no point
	}
}

vector<point> cutPolygon(const vector<point> & P, const point & a, const point & v){
	//returns the part of the convex polygon P on the left side of line a+tv
	int n = P.size();
	vector<point> lhs;
	for(int i = 0; i < n; ++i){
		if(geq(v.cross(P[i] - a), 0)){
			lhs.push_back(P[i]);
		}
		if(intersectLineSegmentInfo(a, v, P[i], P[(i+1)%n]) == 1){
			point p = intersectLines(a, v, P[i], P[(i+1)%n] - P[i]);
			if(p != P[i] && p != P[(i+1)%n]){
				lhs.push_back(p);
			}
		}
	}
	return lhs;
}

vector<point> tangentsPointPolygon(const vector<point> & P, const vector<vector<point>> & Ps, const point & p){
	int n = P.size(), m = Ps[0].size(), k = Ps[1].size();
	
	int lk = m; if(Ps[0][m - 1] == Ps[1][0]) lk--; 

	auto tang = [&](int l, int r, ld w, int kl) -> int {
		int res = min(l, r);
        while(l <= r){
            int m = (l + r) / 2;
			ld a = (P[(m + kl) % n] - p).cross(P[(m + 1 + kl) % n] - p) * w, b = (P[(m + kl) % n] - p).cross(P[(m - 1 + n + kl) % n] - p) * w;
			if(geq(a, 0) && geq(b, 0)) return m;
            if(geq(a, 0)) r = m - 1, res = m;
            else l = m + 1;
        }
        return res;
    };

	auto bs = [&](int l, int r, const vector<point> & A, ld w) -> int {
        int res = l;
        ld w1 = p.x * w;
        while(l <= r){
            int m = (l + r) / 2;
			if(ge(A[m].x * w, w1)) r = m - 1;
			else res = m, l = m + 1;
        }
        return res;
    };
    
	point left = p, rigth = p;

	int t1 = bs(0, m - 1, Ps[0], 1), t2 = bs(0, k - 1, Ps[1], -1);
	
	auto u1 = tang(0, t1, -1, 0), u2 = tang(0, t2, -1, lk);
	auto v1 = tang(t1, m - 1, 1, 0), v2 = tang(t2, k - 1, 1, lk);
	//if(p.x == P[t1].x) v1 = tang(t1, m - 1, 1, 0);
	//if(p.x == P[(lk + t2) % n].x) v2 = tang(t2, k - 1, 1, lk);
	
	if(leq((P[u1] - p).cross(P[(u1 - 1 + n) % n] - p), 0) && leq((P[u1] - p).cross(P[(u1 + 1) % n] - p), 0)) left = P[u1];
	else if(leq((P[(lk + u2) % n] - p).cross(P[(lk + u2 - 1 + n) % n] - p), 0) && leq((P[(lk + u2) % n] - p).cross(P[(lk + u2 + 1) % n] - p), 0)) left = P[(lk + u2) % n];
	
	if(geq((P[v1] - p).cross(P[(v1 - 1 + n) % n] - p), 0) && geq((P[v1] - p).cross(P[(v1 + 1) % n] - p), 0)) rigth = P[v1];
	else if(geq((P[(lk + v2) % n] - p).cross(P[(lk - 1 + n + v2) % n] - p), 0) && geq((P[(lk + v2) % n] - p).cross(P[(lk + 1 + v2) % n] - p), 0)) rigth = P[(lk + v2) % n];
    
	return {left, rigth};
}

vector<point> tangentsLineal(vector<point> A, point p){
    int iz = 0, dr = 0, n = A.size();
    for(int i = 0; i < n; i++){
        int at = i - 1, nx = i + 1;
        if(at < 0) at = n - 1; if(nx == n) nx = 0;
        if(leq((A[i] - p).cross(A[at] - p), 0) && leq((A[i] - p).cross(A[nx] - p), 0)) iz = i;
        if(geq((A[i] - p).cross(A[at] - p), 0) && geq((A[i] - p).cross(A[nx] - p), 0)) dr = i;
    }
    return {A[iz], A[dr]};
}

pair<fraccion, fraccion> calc(vector<point> & A, vector<point> B, vector<vector<point>> & tws, int l, int r){
    fraccion minx = Inf2, maxx = -Inf2;
    pointf x0(-Inf2, 0), x1(Inf2, 0);
    point s0(-Inf2, 0), s1(Inf2, 0);
    point w1(l, 0), w2(r, 0);
    int n = B.size();
    for(int i = 0; i < n; i++){
        auto u = intersectSegmentsInfo(B[i], B[(i + 1) % n], s0, s1);
        if(u == 1){
            auto p = intersectLinesf(B[i], B[(i + 1) % n] - B[i], s0, s1 - s0);
            //minx = min(minx, p.x); maxx = max(maxx, p.x);
        }else if(u == -1){
            //minx = min(minx, min(fraccion(B[i].x), fraccion(B[(i + 1) % n].x)));
            //maxx = max(maxx, max(fraccion(B[i].x), fraccion(B[(i + 1) % n].x)));
        }
    }
    point a1(1, 0);
    for(int i = 0; i < n; i++){
        auto ts = tangentsPointPolygon(A, tws, B[i]);
        point t1 = ts[0], t2 = ts[1];
        //cout<<B[i]<<" => "<<t1<<" & "<<t2<<'\n';
        if(neq(a1.cross(t1 - B[i]), 0)){
            auto p1 = intersectLinesf(B[i], t1 - B[i], point(0, 0), a1);
            auto p2 = intersectLines(B[i], t1 - B[i], point(0, 0), a1);
            bool pl = true;
			point p(p1.x.value(), p1.y.value());
            //cout<<p.x.value()<<" , "<<p.y.value()<<" | ";
            if(eq((p - t1).length(), (p - B[i]).length() + (B[i] - t1).length()) && pl){
                //cout<<"r";
                if(minx > p1.x) minx = p1.x; if(maxx < p1.x) maxx = p1.x;
                
            }
        }
        if(neq(a1.cross(t2 - B[i]), 0)){
            auto p1 = intersectLinesf(B[i], t2 - B[i], point(0, 0), a1);
            auto p2 = intersectLines(B[i], t2 - B[i], point(0, 0), a1);
            bool pl = true;
            point p(p1.x.value(), p1.y.value());
			//cout<<p.x.value()<<" , "<<p.y.value()<<'\n';
            if(eq((p - t2).length(), (p - B[i]).length() + (B[i] - t2).length()) && pl){
                //cout<<"r";
                if(minx > p1.x) minx = p1.x; if(maxx < p1.x) maxx = p1.x;
                
            }
        }
        
        //if(ge((t1 - B[i]).cross(w1 - B[i]), 0) && le((t2 - B[i]).cross(w1 - B[i]), 0)) minx = -Inf2;
        //if(ge((t1 - B[i]).cross(w2 - B[i]), 0) && le((t2 - B[i]).cross(w2 - B[i]), 0)) maxx = Inf2;
        
    }
    
    auto itg0 = tangentsPointPolygon(A, tws, w1);
    auto itg1 = tangentsLineal(B, w1);
    auto dtg0 = tangentsPointPolygon(A, tws, w2);
    auto dtg1 = tangentsLineal(B, w2);
    
    auto t0 = itg0[0], t1 = itg0[1], t2 = itg1[0], t3 = itg1[1];
    auto t4 = dtg0[0], t5 = dtg0[1], t6 = dtg1[0], t7 = dtg1[1];
    
    auto v = B;
    v = cutPolygon(v, w1, w1 - t0); v = cutPolygon(v, w1, t1 - w1); v = cutPolygon(v, t1, t0 - t1);
    
    if(area(v) > 0.0001){
        minx = -Inf2;
    }
    
    /*
        if(leq((t2 - w1).cross(t0 - w1), 0) && geq((t3 - w1).cross(t0 - w1), 0)) minx = -Inf2;
        if(leq((t2 - w1).cross(t1 - w1), 0) && geq((t3 - w1).cross(t1 - w1), 0)) minx = -Inf2;
        if(leq((t0 - w1).cross(t2 - w1), 0) && geq((t1 - w1).cross(t2 - w1), 0)) minx = -Inf2;
    */
    
    v = B;
    v = cutPolygon(v, w2, w2 - t4); v = cutPolygon(v, w2, t5 - w2); v = cutPolygon(v, t5, t4 - t5);
        
    if(area(v) > 0.0001){
        maxx = Inf2;
    }
    
    /*
        if(leq((t6 - w2).cross(t4 - w2), 0) && geq((t7 - w2).cross(t4 - w2), 0)) maxx = Inf2;
        if(leq((t6 - w2).cross(t5 - w2), 0) && geq((t7 - w2).cross(t5 - w2), 0)) maxx = Inf2;
        if(leq((t4 - w2).cross(t6 - w2), 0) && geq((t5 - w2).cross(t6 - w2), 0)) maxx = Inf2;
    */
    //cout<<minx.value()<<" "<<maxx.value()<<'\n';
    //if(minx == -Inf2 && maxx == Inf2) return {Inf2, Inf2};
    return {minx, maxx};
}

ld calc1(){
    int m, l, r; cin>>m>>l>>r;
    int n; cin>>n;
    vector<point> P(n);
    for(int i = 0; i < n; i++){
        int a, b; cin>>a>>b; P[i] = point(a, b);
    }
    vector<vector<point>> Moons;
    for(int i = 0; i < m; i++){
        int k; cin>>k; vector<point> aux;
        for(int j = 0; j < k; j++){
            int a, b; cin>>a>>b; aux.pb(point(a, b));
        }
        Moons.pb(aux);
    }
    
    P = convexHull(P);
	auto tws = twoSidesCH(P);
	//for(auto e : tws[1]) cout<<e<<" "; cout<<'\n';
	//for(auto e : tw) cout<<e<<" "; cout<<'\n';
    vector<pair<fraccion, fraccion>> Segs;
    for(int i = 0; i < m; i++){
        auto u = calc(P, Moons[i], tws, l , r);
        //cout<<'\n'<<"----------------------------------------"<<'\n';
        Segs.pb(u);
    }
    sort(all(Segs));
    //for(auto e : Segs) cout<<setprecision(15)<<e.fi.value()<<" , "<<e.se.value()<<" | "; cout<<'\n';
    //cout<<(fraccion(Segs[0].se) - fraccion(Segs[0].fi)).value()<<" ";
    ld ans = 0; fraccion ant(l); bool f = false;
    for(int i = 0; i < m; i++){
        if(Segs[i].fi > fraccion(r)){
            if(fraccion(r) > ant){
                f = true;
            }
            if(ant < fraccion(r)) ans += (fraccion(r).value() - ant.value());
            ant = r;
            break;
        }
        if(Segs[i].fi >= ant){
            if(!((Segs[i].fi == l && ant == l) || (Segs[i].fi == r && ant == r))) f = true; 
            //cout<<(Segs[i].fi - ant).value();
        }
        if(ant < Segs[i].fi) ans += abs(ant.value() - Segs[i].fi.value());
        ant = max(ant, Segs[i].se);
        //cout<<ans<<'\n';
    }
    if(ant < r) ans += (fraccion(r).value() - max(ant.value(), fraccion(l).value())), f = true;
    if(!f && ans == 0) return -1;
    return ans;
}

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int t; cin>>t;
    while(t--){
		auto p = calc1();
        cout<<setprecision(25)<<p<<'\n';
    }
}