#include <iostream>
#include <ctime>
#include <cmath>
#include <iomanip>
#include <random>
#include <chrono>
#include <algorithm>

#define ld long double

using namespace std;

const ld EPS = 1e-10;

mt19937 myRand(chrono::steady_clock::now().time_since_epoch().count());

struct Vector2 {
    ld x = 0;
    ld y = 0;
    Vector2 operator+(const Vector2& other) const {
        return { x + other.x, y + other.y };
    }
    Vector2 operator+=(const Vector2& other) {
        x += other.x;
        y += other.y;
        return *this;
    }
    Vector2 operator-(const Vector2& other) const {
        return { x - other.x, y - other.y };
    }
    Vector2 operator-=(const Vector2& other) {
        x -= other.x;
        y -= other.y;
        return *this;
    }
    Vector2 operator*(ld other) const {
        return { x * other, y * other };
    }
    Vector2 operator/(ld other) const {
        return { x / other, y / other };
    }
    ld Mod() const {
        return sqrt(x * x + y * y);
    }
    ld Mod2() const {
        return x * x + y * y;
    }
};

ld Dis(const Vector2& a, const Vector2& b) {
    return (b - a).Mod();
}

ld Dis2(const Vector2& a, const Vector2& b) {
    return (b - a).Mod2();
}

Vector2 ChangeDis(const Vector2& a, ld dis) {
    return a * (dis / a.Mod());
}

//ax+by=c
//dx+ey=f
pair<ld, ld> SolveXY(ld a, ld b, ld c, ld d, ld e, ld f) {
    ld mu = a * e - b * d;
    // cout << mu << endl;
    return { (c * e - b * f) / mu, (a * f - c * d) / mu };
}

pair<Vector2, ld> Circle(Vector2 p1, Vector2 p2, Vector2 p3) {
    const auto& [x1, y1] = p1;
    const auto& [x2, y2] = p2;
    const auto& [x3, y3] = p3;
    ld a = 2 * (x2 - x1);
    ld b = 2 * (y2 - y1);
    ld c = x2 * x2 + y2 * y2 - x1 * x1 - y1 * y1;
    ld d = 2 * (x3 - x1);
    ld e = 2 * (y3 - y1);
    ld f = x3 * x3 + y3 * y3 - x1 * x1 - y1 * y1;
    auto [x, y] = SolveXY(a, b, c, d, e, f);
    Vector2 center = { x, y };
    return { center, Dis2(p1, center) };
}

Vector2 Mid(const Vector2& a, const Vector2& b) {
    return (a + b) / 2;
}

int n;
int m;
Vector2 news[1010];
Vector2 olds[1010];
Vector2 moves[1010000];

ld r;
Vector2 center;

void Zxyfg() {
    shuffle(moves, moves + n * m, myRand);
    r = 0;
    center = moves[0];
    // cout << moves[0].x << ',' << moves[1].x << endl;
    for (int i = 1; i < n * m; i++) {
        auto p1 = moves[i];
        auto dis = Dis2(center, p1);
        if (dis > r) {
            center = p1;
            r = 0;
            for (int j = 0; j < i; j++) {
                auto p2 = moves[j];
                auto dis = Dis2(center, p2);
                if (dis > r) {
                    center = Mid(p1, p2);
                    r = Dis2(p2, center);
                    for (int k = 0; k < j; k++) {
                        auto p3 = moves[k];
                        auto dis = Dis2(center, p3);
                        if (dis > r) {
                            tie(center, r) = Circle(p1, p2, p3);
                        }
                    }
                }
            }
        }
        // cout << p1.x << ',' << p1.y << endl;
        // cout << i << ',' << r << endl;
    }
}

void Solve() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> news[i].x >> news[i].y;
    }
    cin >> m;
    for (int i = 0; i < m; i++) {
        cin >> olds[i].x >> olds[i].y;
        for (int j = 0; j < n; j++) {
            moves[i * n + j] = olds[i] - news[j];
        }
    }
    Zxyfg();
    cout << setprecision(114514) << sqrt(r) << ' ' << center.x << ' ' << center.y;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    Solve();
    return 0;
}