#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
typedef long double db;
const db inf=1e100;
const db eps=1e-10;
const db pi=acos(db(-1));
int sgn(db x)
{
    if(x>eps)return 1;
    if(x<-eps)return -1;
    return 0;
}
struct Point
{
    db x,y;
    Point() {}
    Point(db _x,db _y):x(_x),y(_y) {}
    Point operator + (const Point& t)const
    {
        return Point(x+t.x,y+t.y);
    }
    Point operator - (const Point& t)const
    {
        return Point(x-t.x,y-t.y);
    }
    Point operator * (const db& t)const
    {
        return Point(x*t,y*t);
    }
    Point operator / (const db& t)const
    {
        return Point(x/t,y/t);
    }
    db operator * (const Point& t)const
    {
        return x*t.y-y*t.x;
    }
    db operator ^ (const Point& t)const
    {
        return x*t.x+y*t.y;
    }
    db len()const
    {
        return sqrt(x*x+y*y);
    }
    Point norm()const
    {
        return *this/len();
    }
    Point rot90()const
    {
        return Point(-y,x);
    }
    Point rot(db tx,db ty)const
    {
        db r=sqrt(tx*tx+ty*ty),c=tx/r,s=ty/r;
        return Point(x*c-y*s,x*s+y*c);
    }
    bool operator < (const Point &t)const
    {
        return sgn(x-t.x)==0 ? y<t.y : x<t.x;
    }
    void read()
    {
        int tx,ty;
        scanf("%d%d",&tx,&ty);
        x=tx,y=ty;
    }
};
struct Line
{
    Point s,v;
    Line() {}
    Line(const Point& _s,const Point& _v):s(_s),v(_v.norm()) {}
    bool left(const Point& p)const
    {
        return sgn((p-s)*v)<0;
    }
    pair<bool,Point> operator & (const Line &t)const
    {
        db c=v*t.v;
        if(sgn(c)==0)return make_pair(0,Point());
        return make_pair(1,s+v*(((t.s-s)*t.v)/c));
    }
};
pair<vector<Point>,vector<Line>> halfplane_intersect(vector<Line> lines)
{
    sort(lines.begin(),lines.end(),[&](const Line& lhs,const Line& rhs)
    {
        bool up[2]= {lhs.v.y>0 || (lhs.v.y==0 && lhs.v.x>0),
                     rhs.v.y>0 || (rhs.v.y==0 && rhs.v.x>0)
                    };
        if(up[0]^up[1])return up[0];
        return lhs.v*rhs.v>0;
    });
    vector<Point> p(lines.size());
    vector<Line> hp(lines.size());
    hp[0]=lines[0];
    int h=0,t=0;
    for(size_t i=1; i<lines.size(); i++)
    {
        while(h<t && !lines[i].left(p[t-1]))t--;
        while(h<t && !lines[i].left(p[h]))h++;
        if(sgn(lines[i].v*hp[t].v)!=0)hp[++t]=lines[i];
        else if(!lines[i].left(hp[t].s))hp[t]=lines[i];
        if(h<t)p[t-1]=(hp[t]&hp[t-1]).second;
    }
    while(h<t && !hp[h].left(p[t-1]))t--;
    if(t-h<2)return {};
    p[t]=(hp[t]&hp[h]).second;
    db area=0;
    for(int i=0; i<=t-h; i++)
        area+=p[i+h]*p[(i+1)%(t-h+1)+h];
    if(sgn(area)<=0)return {};
    return {vector<Point>(p.begin()+h,p.begin()+t+1),
            vector<Line>(hp.begin()+h,hp.begin()+t+1)};
}
db area(const vector<Point>& p)
{
    if(p.size()<3)return 0;
    db res=0;
    for(size_t i=1; i+1<p.size(); i++)
        res+=(p[i]-p[0])*(p[i+1]-p[0])/2;
    return res;
}
vector<Point> convex_hull(vector<Point> pts,bool upper)
{
    if(upper)for(auto& p : pts)p.y*=-1;
    sort(pts.begin(),pts.end());
    vector<Point> stk;
    int top=0;
    for(size_t i=0; i<pts.size(); i++)
    {
        if(i>0 && sgn(pts[i].x-pts[i-1].x)==0)continue;
        while(top>1 && sgn((pts[i]-stk[top-1])*(stk[top-1]-stk[top-2]))>=0)
            stk.pop_back(),--top;
        stk.push_back(pts[i]),++top;
    }
    if(upper)for(auto& p : stk)p.y*=-1;
    return stk;
}
bool get_hull_y(const vector<Point>& hull,db x,db& y)
{
    auto itr=lower_bound(hull.begin(),hull.end(),Point(x-eps,-inf));
    if(itr==hull.end())return 0;
    if(itr==hull.begin())
    {
        if(sgn(x - itr->x)<0)return 0;
        y = itr->y;
        return 1;
    }
    auto pre=prev(itr);
    y=(x - pre->x)*((itr->y - pre->y)/(itr->x - pre->x)) + pre->y;
    return 1;
}
struct Slice
{
    db l,r,ld[2],lu[2],rd[2],ru[2];
    db cal(db t)
    {
        vector<Line> line;
        line.emplace_back(Point(l,0),Point(0,-1));
        line.emplace_back(Point(r,0),Point(0,1));
        for(int i=0; i<2; i++)
        {
            line.emplace_back(Point(l,ld[i]+(i==0)*t),Point(r-l,rd[i]-ld[i]));
            line.emplace_back(Point(r,ru[i]+(i==0)*t),Point(l-r,lu[i]-ru[i]));
        }
        return area(halfplane_intersect(move(line)).first);
    }
};
struct AreaFunc
{
    db l,r,a,b,c; // at^2+bt+c (l<=t<=r)
};
int solve()
{
    // input
    Point po,pv;
    int z0,z1,z2,n1,n2;
    po.read();
    scanf("%d",&z0);
    pv.read();
    scanf("%d%d",&n1,&z1);
    vector<Point> p1(n1);
    for(int i=0; i<n1; i++)
        p1[i].read();
    scanf("%d%d",&n2,&z2);
    vector<Point> p2(n2);
    for(int i=0; i<n2; i++)
        p2[i].read();

    // normalize
    db rat=1.0L*(z0-z2)/(z0-z1);
    for(int i=0; i<n1; i++)
        p1[i]=p1[i]*rat+po*(1-rat);
    for(int i=0; i<n1; i++)
        p1[i]=p1[i].rot(pv.x,-pv.y).rot90();
    for(int i=0; i<n2; i++)
        p2[i]=p2[i].rot(pv.x,-pv.y).rot90();
    rat=1.0L*z0/(z0-z2);
    db v=pv.len()*(z2-z1)/(z0-z1);

    // slice
    auto d1=convex_hull(p1,0);
    auto u1=convex_hull(p1,1);
    auto d2=convex_hull(p2,0);
    auto u2=convex_hull(p2,1);
    vector<db> all_x;
    for(int i=0; i<n1; i++)
        all_x.push_back(p1[i].x);
    for(int i=0; i<n2; i++)
        all_x.push_back(p2[i].x);
    sort(all_x.begin(),all_x.end());
    all_x.erase(unique(all_x.begin(),all_x.end()),all_x.end());
    vector<Slice> slice;
    for(size_t i=0; i+1<all_x.size(); i++)
    {
        if(sgn(all_x[i]-all_x[i+1])==0)continue;
        Slice s;
        s.l=all_x[i],s.r=all_x[i+1];
        if(!get_hull_y(d1,s.l,s.ld[0]))continue;
        if(!get_hull_y(u1,s.l,s.lu[0]))continue;
        if(!get_hull_y(d1,s.r,s.rd[0]))continue;
        if(!get_hull_y(u1,s.r,s.ru[0]))continue;
        if(!get_hull_y(d2,s.l,s.ld[1]))continue;
        if(!get_hull_y(u2,s.l,s.lu[1]))continue;
        if(!get_hull_y(d2,s.r,s.rd[1]))continue;
        if(!get_hull_y(u2,s.r,s.ru[1]))continue;
        slice.push_back(move(s));
    }

    // get area_func
    vector<AreaFunc> func;
    for(auto& s : slice)
    {
        vector<db> event;
        event.push_back(s.ld[1]-s.ld[0]);
        event.push_back(s.lu[1]-s.ld[0]);
        event.push_back(s.ld[1]-s.lu[0]);
        event.push_back(s.lu[1]-s.lu[0]);
        event.push_back(s.rd[1]-s.rd[0]);
        event.push_back(s.ru[1]-s.rd[0]);
        event.push_back(s.rd[1]-s.ru[0]);
        event.push_back(s.ru[1]-s.ru[0]);
        for(auto& e : event)e/=v;
        sort(event.begin(),event.end());
        event.erase(unique(event.begin(),event.end()),event.end());
        vector<db> area(event.size()*2-1);
        for(size_t i=0; i<event.size(); i++)
        {
            area[2*i]=s.cal(event[i]*v);
            if(i+1<event.size())
                area[2*i+1]=s.cal((event[i]+event[i+1])/2*v);
        }
        for(size_t i=0; i+1<event.size(); i++)
        {
            db xl=event[i],yl=area[2*i];
            db xm=(event[i]+event[i+1])/2,ym=area[2*i+1];
            db xr=event[i+1],yr=area[2*i+2];
            AreaFunc f;
            f.l=xl,f.r=xr;
            if(sgn(xr-xl)<=0)
            {
                f.a=0;
                f.b=(yr-yl)/(xr-xl);
                f.c=ym-f.b*xm;
            }
            else
            {
                f.a=2*(yl+yr-2*ym)/((xr-xl)*(xr-xl));
                f.b=(yr-yl)/(xr-xl)-f.a*(xl+xr);
                f.c=ym-f.a*xm*xm-f.b*xm;
            }
            func.push_back(move(f));
        }
    }

    // agg area func
    all_x.clear();
    for(auto& f : func)
    {
        all_x.push_back(f.l);
        all_x.push_back(f.r);
    }
    sort(all_x.begin(),all_x.end());
    all_x.erase(unique(all_x.begin(),all_x.end()),all_x.end());
    vector<array<db,3>> area(all_x.size());
    for(auto& f : func)
    {
        size_t i=lower_bound(all_x.begin(),all_x.end(),f.l)-all_x.begin();
        area[i][0]+=f.a,area[i][1]+=f.b,area[i][2]+=f.c;
        i=lower_bound(all_x.begin(),all_x.end(),f.r)-all_x.begin();
        area[i][0]-=f.a,area[i][1]-=f.b,area[i][2]-=f.c;
    }
    for(size_t i=1; i<area.size(); i++)
        for(int j=0; j<3; j++)
            area[i][j]+=area[i-1][j];

    // query
    auto get=[&](const array<db,3>& f,db t)
    {
        return f[0]*t*t+f[1]*t+f[2];
    };
    auto get_val=[&](db t)
    {
        auto itr=lower_bound(all_x.begin(),all_x.end(),t-eps);
        if(itr==all_x.begin() || itr==all_x.end())return db(0);
        return get(area[itr-all_x.begin()-1],t);
    };
    auto get_intgr=[&](const array<db,3>& f,db l,db r)
    {
        return (f[0]*r*r*r/3+f[1]*r*r/2+f[2]*r)-(f[0]*l*l*l/3+f[1]*l*l/2+f[2]*l);
    };
    vector<db> pre_sum(all_x.size());
    for(size_t i=1; i<all_x.size(); i++)
        pre_sum[i]=pre_sum[i-1]+get_intgr(area[i-1],all_x[i-1],all_x[i]);
    auto get_sum=[&](db t)
    {
        auto itr=lower_bound(all_x.begin(),all_x.end(),t-eps);
        if(itr==all_x.begin())return db(0);
        if(itr==all_x.end())return pre_sum[all_x.size()-1];
        int i=itr-all_x.begin()-1;
        return pre_sum[i]+get_intgr(area[i],all_x[i],t);
    };
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int t1,t2;
        scanf("%d%d",&t1,&t2);
        db res;
        if(t1==t2)res=get_val(t1);
        else res=(get_sum(t2)-get_sum(t1))/(t2-t1);
        printf("%.12Lf\n",res*rat*rat);
    }
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)solve();
    return 0;
}

/*#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
typedef long double db;
const db inf=1e100;
const db eps=1e-10;
const db pi=acos(db(-1));
int sgn(db x)
{
    if(x>eps)return 1;
    if(x<-eps)return -1;
    return 0;
}
struct Point
{
    db x,y;
    Point() {}
    Point(db _x,db _y):x(_x),y(_y) {}
    Point operator + (const Point& t)const
    {
        return Point(x+t.x,y+t.y);
    }
    Point operator - (const Point& t)const
    {
        return Point(x-t.x,y-t.y);
    }
    Point operator * (const db& t)const
    {
        return Point(x*t,y*t);
    }
    Point operator / (const db& t)const
    {
        return Point(x/t,y/t);
    }
    db operator * (const Point& t)const
    {
        return x*t.y-y*t.x;
    }
    db operator ^ (const Point& t)const
    {
        return x*t.x+y*t.y;
    }
    db len()const
    {
        return sqrt(x*x+y*y);
    }
    Point norm()const
    {
        return *this/len();
    }
    Point rot90()const
    {
        return Point(-y,x);
    }
    Point rot(db tx,db ty)const
    {
        db r=sqrt(tx*tx+ty*ty),c=tx/r,s=ty/r;
        return Point(x*c-y*s,x*s+y*c);
    }
    bool operator < (const Point &t)const
    {
        return sgn(x-t.x)==0 ? y<t.y : x<t.x;
    }
    void read()
    {
        int tx,ty;
        scanf("%d%d",&tx,&ty);
        x=tx,y=ty;
    }
};
struct Line
{
    Point s,v;
    Line() {}
    Line(const Point& _s,const Point& _v):s(_s),v(_v.norm()) {}
    bool left(const Point& p)const
    {
        return sgn((p-s)*v)<0;
    }
    pair<bool,Point> operator & (const Line &t)const
    {
        db c=v*t.v;
        if(sgn(c)==0)return make_pair(0,Point());
        return make_pair(1,s+v*(((t.s-s)*t.v)/c));
    }
};
pair<vector<Point>,vector<Line>> halfplane_intersect(vector<Line> lines)
{
    sort(lines.begin(),lines.end(),[&](const Line& lhs,const Line& rhs)
    {
        bool up[2]= {lhs.v.y>0 || (lhs.v.y==0 && lhs.v.x>0),
                     rhs.v.y>0 || (rhs.v.y==0 && rhs.v.x>0)
                    };
        if(up[0]^up[1])return up[0];
        return lhs.v*rhs.v>0;
    });
    vector<Point> p(lines.size());
    vector<Line> hp(lines.size());
    hp[0]=lines[0];
    int h=0,t=0;
    for(size_t i=1; i<lines.size(); i++)
    {
        while(h<t && !lines[i].left(p[t-1]))t--;
        while(h<t && !lines[i].left(p[h]))h++;
        if(sgn(lines[i].v*hp[t].v)!=0)hp[++t]=lines[i];
        else if(!lines[i].left(hp[t].s))hp[t]=lines[i];
        if(h<t)p[t-1]=(hp[t]&hp[t-1]).second;
    }
    while(h<t && !hp[h].left(p[t-1]))t--;
    if(t-h<2)return {};
    p[t]=(hp[t]&hp[h]).second;
    db area=0;
    for(int i=0; i<=t-h; i++)
        area+=p[i+h]*p[(i+1)%(t-h+1)+h];
    if(sgn(area)<=0)return {};
    return {vector<Point>(p.begin()+h,p.begin()+t+1),
            vector<Line>(hp.begin()+h,hp.begin()+t+1)};
}
db area(const vector<Point>& p)
{
    if(p.size()<3)return 0;
    db res=0;
    for(size_t i=1; i+1<p.size(); i++)
        res+=(p[i]-p[0])*(p[i+1]-p[0])/2;
    return res;
}
vector<Point> convex_hull(vector<Point> pts,bool upper)
{
    if(upper)for(auto& p : pts)p.y*=-1;
    sort(pts.begin(),pts.end());
    vector<Point> stk;
    int top=0;
    for(size_t i=0; i<pts.size(); i++)
    {
        if(i>0 && sgn(pts[i].x-pts[i-1].x)==0)continue;
        while(top>1 && sgn((pts[i]-stk[top-1])*(stk[top-1]-stk[top-2]))>=0)
            stk.pop_back(),--top;
        stk.push_back(pts[i]),++top;
    }
    if(upper)for(auto& p : stk)p.y*=-1;
    return stk;
}
bool get_hull_y(const vector<Point>& hull,db x,db& y)
{
    auto itr=lower_bound(hull.begin(),hull.end(),Point(x-eps,-inf));
    if(itr==hull.end())return 0;
    if(itr==hull.begin())
    {
        if(sgn(x - itr->x)<0)return 0;
        y = itr->y;
        return 1;
    }
    auto pre=prev(itr);
    y=(x - pre->x)*((itr->y - pre->y)/(itr->x - pre->x)) + pre->y;
    return 1;
}
struct Slice
{
    db l,r,ld[2],lu[2],rd[2],ru[2];
    db cal(db t)
    {
        vector<Line> line;
        line.emplace_back(Point(l,0),Point(0,-1));
        line.emplace_back(Point(r,0),Point(0,1));
        for(int i=0; i<2; i++)
        {
            line.emplace_back(Point(l,ld[i]+(i==0)*t),Point(r-l,rd[i]-ld[i]));
            line.emplace_back(Point(r,ru[i]+(i==0)*t),Point(l-r,lu[i]-ru[i]));
        }
        return area(halfplane_intersect(move(line)).first);
    }
};
struct AreaFunc
{
    db l,r,a,b,c; // at^2+bt+c (l<=t<=r)
};
int solve()
{
    // input
    Point po,pv;
    int z0,z1,z2,n1,n2;
    po.read();
    scanf("%d",&z0);
    pv.read();
    scanf("%d%d",&n1,&z1);
    vector<Point> p1(n1);
    for(int i=0; i<n1; i++)
        p1[i].read();
    scanf("%d%d",&n2,&z2);
    vector<Point> p2(n2);
    for(int i=0; i<n2; i++)
        p2[i].read();

    // normalize
    db rat=1.0L*(z0-z2)/(z0-z1);
    for(int i=0; i<n1; i++)
        p1[i]=p1[i]*rat+po*(1-rat);
    for(int i=0; i<n1; i++)
        p1[i]=p1[i].rot(pv.x,-pv.y).rot90();
    for(int i=0; i<n2; i++)
        p2[i]=p2[i].rot(pv.x,-pv.y).rot90();
    rat=1.0L*z0/(z0-z2);
    db v=pv.len()*(z2-z1)/(z0-z1);

    // slice
    auto d1=convex_hull(p1,0);
    auto u1=convex_hull(p1,1);
    auto d2=convex_hull(p2,0);
    auto u2=convex_hull(p2,1);
    vector<db> all_x;
    for(int i=0; i<n1; i++)
        all_x.push_back(p1[i].x);
    for(int i=0; i<n2; i++)
        all_x.push_back(p2[i].x);
    sort(all_x.begin(),all_x.end());
    all_x.erase(unique(all_x.begin(),all_x.end()),all_x.end());
    vector<Slice> slice;
    for(size_t i=0; i+1<all_x.size(); i++)
    {
        if(sgn(all_x[i]-all_x[i+1])==0)continue;
        Slice s;
        s.l=all_x[i],s.r=all_x[i+1];
        if(!get_hull_y(d1,s.l,s.ld[0]))continue;
        if(!get_hull_y(u1,s.l,s.lu[0]))continue;
        if(!get_hull_y(d1,s.r,s.rd[0]))continue;
        if(!get_hull_y(u1,s.r,s.ru[0]))continue;
        if(!get_hull_y(d2,s.l,s.ld[1]))continue;
        if(!get_hull_y(u2,s.l,s.lu[1]))continue;
        if(!get_hull_y(d2,s.r,s.rd[1]))continue;
        if(!get_hull_y(u2,s.r,s.ru[1]))continue;
        slice.push_back(move(s));
    }

    // get area_func
    vector<AreaFunc> func;
    for(auto& s : slice)
    {
        vector<db> event;
        event.push_back(s.ld[1]-s.ld[0]);
        event.push_back(s.lu[1]-s.ld[0]);
        event.push_back(s.ld[1]-s.lu[0]);
        event.push_back(s.lu[1]-s.lu[0]);
        event.push_back(s.rd[1]-s.rd[0]);
        event.push_back(s.ru[1]-s.rd[0]);
        event.push_back(s.rd[1]-s.ru[0]);
        event.push_back(s.ru[1]-s.ru[0]);
        for(auto& e : event)e/=v;
        sort(event.begin(),event.end());
        event.erase(unique(event.begin(),event.end()),event.end());
        vector<db> area(event.size()*2-1);
        for(size_t i=0; i<event.size(); i++)
        {
            area[2*i]=s.cal(event[i]*v);
            if(i+1<event.size())
                area[2*i+1]=s.cal((event[i]+event[i+1])/2*v);
        }
        for(size_t i=0; i+1<event.size(); i++)
{
    int T;
    scanf("%d",&T);
    while(T--)solve();
    return 0;
}
*/