//
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef double ld;
typedef long long ll;
int n, m;
struct Point{
    ld x, y;
    Point(ld x, ld y) : x(x), y(y) {}
    Point() {}
};
Point operator-(const Point& a, const Point& b) {
    return Point{a.x - b.x, a.y - b.y};
}
ld operator *(const Point& a, const Point& b) {
    return a.x * b.y - a.y * b.x;
}

ld det(ld a11, ld a12, ld a21, ld a22) {
    return (a11 * a22 - a21 * a12);
}
const ld eps = 1e-8;
bool Gr(ld a, ld b) {
    return a - b > eps;
}
bool Eq(ld a, ld b) {
    return fabs(a - b) < eps;
}
struct Plane{
    Point v;
    Point M;
    Plane() {}
    Plane(const Point& f2, const Point& f1) {
        M = f2;
        ld len = sqrt(f1.x * f1.x + f1.y * f1.y);
        v = {f1.x / len, f1.y / len};
    }
    bool contain(const Point& f) const {
        return Gr(v * (f - M), 0.0);
    }
    Point getPoint(const Plane& other) {
        ld D = det(v.x, -other.v.x, v.y, -other.v.y);
        if (Eq(D, 0.0)) return {1e12, 1e12};
        ld alpha = det(other.M.x - M.x, -other.v.x, other.M.y - M.y, -other.v.y) / D;
        Point t{M.x + alpha * v.x, M.y + alpha * v.y};
        return t;
    }
};

int half(const Point& v) {
    if (Gr(v.y, 0.0) || (Eq(v.y, 0.0) && Gr(v.x, 0.0))) return 1;
    return 2;
}
bool cmpPlane(const Plane& a, const Plane& b) {
    if (half(a.v) != half(b.v)) {
        return half(a.v) < half(b.v);
    }
    ld d = a.v * b.v;
    if (!Eq(d, 0.0)) {
        return d > eps;
    }
    return b.contain(a.M);
}
bool eqPlane(const Plane& a, const Plane& b) {
    return Eq(a.v * b.v, 0.0);
}
const int maxN = 500005;
Plane pl[maxN];
Plane res[maxN];
const ld maxC = (ld)1e9 + 148888;
Point ans[maxN];
int cntPl = 0;
int halfPlaneIntersect() {
    Point box[4];
    box[0] = Point(-maxC, -maxC);
    box[1] = Point(maxC, -maxC);
    box[2] = Point(maxC, maxC);
    box[3] = Point(-maxC, maxC);
    for (int i = 0; i < 4; i++) {
        pl[cntPl++] = Plane(box[i], box[(i + 1) % 4] - box[i]);
    }
    sort(pl, pl + cntPl, cmpPlane);
    cntPl = unique(pl, pl + cntPl, eqPlane) - pl;
    int l = 0;
    int r = 0;
    for (int i = 0; i < cntPl; i++) {
        while (r - l > 1 && !pl[i].contain(res[r - 1].getPoint(res[r - 2]))) {
            r--;
        }
        while (r - l > 1 && !pl[i].contain(res[l].getPoint(res[l + 1]))) {
            l++;
        }
        if (r - l > 0 && (Eq(res[r - 1].v * pl[i].v, 0.0) || Gr(0.0, res[r - 1].v * pl[i].v))) return 0;
        if (r - l < 2 || res[l].contain(pl[i].getPoint(res[r - 1]))) {
            res[r++] = pl[i];
        }
    }
    int cntPts = 0;
    for (int i = l; i < r - 1; i++) {
        ans[cntPts++] = res[i].getPoint(res[i + 1]);
    }
    ans[cntPts++] = res[l].getPoint(res[r - 1]);
    return cntPts;
}
Point a[maxN], b[maxN];
ld dist(Point& a, Point& b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

const ld LIM = 1e9 - 15;
const int maxP = 2e5 + 10;
const ld gold_ratio =  (1.0 + sqrt(5)) / 2;

ld A[maxP], B[maxP], C[maxP], D[maxP];

int SZ = 0;
ld optX;
ld optY;
ld optZ;
ld getZ(ld X, ld Y) {
    ld at_least = -5e18;
    ld at_most = 5e18;
    for (int i = 0; i < SZ; i++) {
        if (C[i] > 0) {
            at_least = max(at_least, (-D[i] - A[i] * X - B[i] * Y) / C[i]);
        } else {
            at_most = min(at_most, (-D[i] - A[i] * X - B[i] * Y) / C[i]);
        }
    }
    optZ = (at_most + at_least) / 2;
    return at_most - at_least;
}
ld getY(ld X) {
    optX = X;
    ld min_y = -LIM;
    ld max_y = LIM;
    ld le_y = (gold_ratio * min_y + max_y) / (gold_ratio + 1);
    ld val_le = getZ(X, le_y);
    ld ri_y = (gold_ratio * max_y + min_y) / (gold_ratio + 1);
    ld val_ri = getZ(X, ri_y);
    for (int iter = 0; iter < 60; iter++) {
        if (val_le < val_ri) {
            min_y = le_y;
            le_y =  ri_y;
            val_le = val_ri;
            ri_y = (gold_ratio * max_y + min_y) / (gold_ratio + 1);
            val_ri = getZ(X, ri_y);
        }
        else {
            max_y = ri_y;
            ri_y = le_y;
            val_ri = val_le;
            le_y = (gold_ratio * min_y + max_y) / (gold_ratio + 1);
            val_le = getZ(X, le_y);
        }
    }
    optY = (min_y + max_y) / 2;
    return getZ(X, optY);
}
void other_solve() {
    SZ = 0;
    for (int i = 0; i < n; i++) {
        A[SZ] = -2 * a[i].x;
        B[SZ] = -2 * a[i].y;
        C[SZ] = -1;
        D[SZ] = a[i].x * a[i].x + a[i].y * a[i].y;
        SZ++;
    }
    for (int i = 0; i < m; i++) {
        A[SZ] = 2 * b[i].x;
        B[SZ] = 2 * b[i].y;
        C[SZ] = 1;
        D[SZ] = -b[i].x * b[i].x -b[i].y * b[i].y;
        SZ++;
    }
    ld min_x = -LIM;
    ld max_x = LIM;

    ld le_x = (gold_ratio * min_x + max_x) / (gold_ratio + 1);
    ld val_le = getY(le_x);
    ld ri_x = (gold_ratio * max_x + min_x) / (gold_ratio + 1);
    ld val_ri = getY(ri_x);
    for (int iter = 0; iter < 60; iter++) {
        if (val_le < val_ri) {
            min_x = le_x;
            le_x =  ri_x;
            val_le = val_ri;
            ri_x = (gold_ratio * max_x + min_x) / (gold_ratio + 1);
            val_ri = getY(ri_x);
        }
        else {
            max_x = ri_x;
            ri_x = le_x;
            val_ri = val_le;
            le_x = (gold_ratio * min_x + max_x) / (gold_ratio + 1);
            val_le = getY(le_x);
        }
    }
    ld x = (min_x + max_x) / 2;
    getY(x);
    ld y = optY;

    //    cout << x << " " << y << " " << getZ(x, y) << " " << getY(x) << endl;
    assert(getZ(x, y) >= 0);
    ld r_sq = optZ + x * x + y * y;
    r_sq = sqrt(r_sq);
    cout << fixed << setprecision(12) << r_sq  << "\n" << x << " " << y << '\n';
}

void solve() {
    cntPl = 0;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    cin >> m;
    for (int i = 0; i < m; i++) {
        cin >> b[i].x >> b[i].y;
    }
    other_solve();
    return;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            Point mid = {(a[i].x + b[j].x) / 2, (a[i].y + b[j].y) / 2};
            Point r = b[j] - a[i];
            Point f(mid.x + r.y, mid.y - r.x);
            pl[cntPl++] = Plane(mid, f - mid);
            assert(pl[cntPl - 1].contain(b[j]));
            assert(!pl[cntPl - 1].contain(a[i]));
        }
    }

    int D = halfPlaneIntersect();
    // if (D == 0) {
    //     cout << "NO\n";
    //     return;
    // }
    assert(D != 0);
    Point cent = {0, 0};
    for (int i = 0; i < D; i++) {
        cent.x += (ans[i].x);
        cent.y += (ans[i].y);
    }
    cent.x /= D;
    cent.y /= D;
    ld min_dist = 1e18;
    ld max_dist = 0;
    for (int i = 0; i < n; i++) {
        min_dist = min(min_dist, dist(a[i], cent));
    }
    for (int i = 0; i < m; i++) {
        max_dist = max(max_dist, dist(b[i], cent));
    }
    ld rad = sqrt(min_dist * max_dist);
    assert(max_dist < min_dist);
    cout << fixed << setprecision(12) << rad << '\n' << cent.x << " " << cent.y << '\n';


}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    //    freopen("input.txt", "r", stdin);
    int tst;
    cin >> tst;
    while (tst--) solve();
    return 0;
}