#include <bits/stdc++.h>

const int N = 55;
const double eps = 1e-9;
const double PI = acos(-1.0);

// std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
std::mt19937 rng(410);
std::uniform_real_distribution <> rel(0, 0.5);

const double rotate_deg = rel(rng) * PI;

struct point{
	double x, y;
}E;

struct polygon{
	int n;
	std::vector <point> a;
	point& operator [] (int i){return a[i];}
};

struct line{
	double k, b;
};

struct segment{
	point A, B;
	double k, b;
	segment(point _A, point _B){
		A = _A, B = _B;
		k = (A.y - B.y) / (A.x - B.x);
		b = A.y - k * A.x;
	}
};
segment Lray(E, E), Rray(E, E);


void print(point P){
    printf("(%.6lf, %.6lf)\n", P.x, P.y);
}

point rotate(point A, double deg){
	return {A.x * cos(deg) - A.y * sin(deg), A.x * sin(deg) + A.y * cos(deg)};
}

bool on_segment(point P, segment L){
	if(fabs(L.k * P.x + L.b - P.y) > eps) return 0;
	if(L.A.x > L.B.x) std::swap(L.A, L.B);
	return L.A.x - eps <= P.x && P.x <= L.B.x + eps;
}

bool point_in_polygon(point P, polygon G, bool flg){
	// P 向正右侧引出射线
	int cnt = 0;
	for(int i = 0; i < G.n; ++i){
		int u = i, v = (i + 1) % G.n;
		if(G[u].y < G[v].y) std::swap(u, v);
		segment L(G[u], G[v]);
		if(on_segment(P, L)) return flg; // 在边界上
		if(!(G[u].y >= P.y - eps && G[v].y + eps < P.y)) continue;
		double cross_x = (P.y - L.b) / L.k;
		if(cross_x >= P.x - eps) ++cnt;
	}
	return cnt & 1;
}

bool intersect(segment L, segment M, point &I){ // 是否与非端点相交 
	if(L.k == M.k) return 0; // 在题目中平行和重合都被视为合法 
	// L.k * x + L.b = y
    // M.k * x + M.b = y
    point P;
    P.x = (M.b - L.b) / (L.k - M.k), P.y = L.k * P.x + L.b;
    if(on_segment(P, L) && on_segment(P, M)){
        I = P;
        return 1;
    }
    else return 0;
}

polygon A, B;

void test1(){
	polygon G;
	G.n = 3;
	G.a.push_back({0, 0}), G.a.push_back({4, 2}), G.a.push_back({1, 4});
	point A = {-1, 2}, B = {-1, 4}, C = {-1, 0}, D = {0.5, 2}, E = {2, 1}, F = {2.0000001, 1};
	std::cerr << point_in_polygon(A, G, 1) << '\n';
	std::cerr << point_in_polygon(B, G, 1) << '\n';
	std::cerr << point_in_polygon(C, G, 1) << '\n';
	std::cerr << point_in_polygon(D, G, 1) << '\n';
	std::cerr << point_in_polygon(E, G, 1) << '\n';
	std::cerr << point_in_polygon(F, G, 1) << '\n';
}

bool valid[N << 1][N << 1];
double chk_x, chk_y, dis[N << 1][N << 1];
double f[N << 1][N << 1][2][2];

bool cro[2][N << 1][N << 1];

bool get_validity(int i, int j){
    point P, Q;
    if(i < A.n) P = A[i];
    else P = B[i - A.n];
    if(j < A.n) Q = A[j];
    else Q = B[j - A.n];
    // std::cerr << "i: " << i << " ", print(P);
    // std::cerr << "j: " << j << " ", print(Q);
    dis[i][j] = dis[j][i] = sqrtl((P.x - Q.x) * (P.x - Q.x) + (P.y - Q.y) * (P.y - Q.y));
    segment L(P, Q);
    std::vector <point> nds; // intersections
    for(int i = 0; i < A.n; ++i){
        int u = i, v = (i + 1) % A.n;
        segment M(A[u], A[v]);
        point R;
        if(intersect(L, M, R)) nds.push_back(R);
    }
    for(int i = 0; i < B.n; ++i){
        int u = i, v = (i + 1) % B.n;
        segment M(B[u], B[v]);
        point R;
        if(intersect(L, M, R)) nds.push_back(R);
    }
    nds.push_back(P), nds.push_back(Q);
    std::sort(nds.begin(), nds.end(), [&](point I, point J){return I.x == J.x ? I.y < J.y : I.x < J.x;});
    int siz = nds.size();
    // std::cerr << "size: " << siz << '\n';
    for(int i = 1; i < siz; ++i){
        point Midpoint = {(nds[i - 1].x + nds[i].x) / 2.0, (nds[i - 1].y + nds[i].y) / 2.0};
        if(point_in_polygon(Midpoint, A, 0) || !point_in_polygon(Midpoint, B, 1)) return 0;
    }
    point R;
    if(intersect(L, Lray, R)) cro[0][i][j] = cro[0][j][i] = 1;
    if(intersect(L, Rray, R)) cro[1][i][j] = cro[1][j][i] = 1;
    return 1;
}

int main(){
    // freopen("test.in", "r", stdin);
	// test1();
    E = {0, 0};
    std::cin >> A.n;
    for(int i = 0; i < A.n; ++i){
        double x, y;
        std::cin >> x >> y;
        point P = {x, y};
        P = rotate(P, rotate_deg);
        // print(P);
        A.a.push_back(P);
    }
    std::cin >> B.n;
    for(int i = 0; i < B.n; ++i){
        double x, y;
        std::cin >> x >> y;
        point P = {x, y};
        P = rotate(P, rotate_deg);
        // print(P);
        B.a.push_back(P);
    }
    chk_x = (A[0].x + A[1].x) / 2.0, chk_y = (A[0].y + A[1].y) / 2.0;
    // print({chk_x, chk_y});
    point tmp = {chk_x - 1e-3, chk_y};
    if(point_in_polygon(tmp, A, 0)) chk_x -= 1e-3;
    else chk_x += 1e-3;
    // print({chk_x, chk_y});
    Lray = segment({chk_x, chk_y}, {1e9, chk_y}), Rray = segment({chk_x, chk_y}, {-1e9, chk_y});
    // std::cerr << Lray.k << " " << Lray.b << " " << Rray.k << " " << Rray.b << '\n';
    for(int i = 0; i < A.n + B.n; ++i){
        valid[i][i] = 1;
        for(int j = i + 1; j < A.n + B.n; ++j){
            valid[i][j] = valid[j][i] = get_validity(i, j);
            // std::cerr << i << " " << j << " " << dis[i][j] << " " << valid[i][j] << " " << cro[0][i][j] << " " << cro[1][i][j] << '\n';
        }
    }
    double ans = 1e15;
    for(int st = 0; st < A.n + B.n; ++st){
        for(int i = 0; i <= A.n + B.n; ++i){
            for(int j = 0; j < A.n + B.n; ++j){
                for(int o = 0; o < 2; ++o){
                    for(int p = 0; p < 2; ++p) f[i][j][o][p] = 1e15;
                }
            }
        }
        f[0][st][0][0] = 0;
        for(int i = 1; i <= A.n + B.n; ++i){
            for(int j = 0; j < A.n + B.n; ++j){
                for(int o = 0; o < 2; ++o){
                    for(int p = 0; p < 2; ++p){
                        if(f[i - 1][j][o][p] >= 1e15) continue;
                        for(int k = 0; k < A.n + B.n; ++k) if(j != k && valid[j][k]){
                            double &t = f[i][k][o ^ cro[0][j][k]][p ^ cro[1][j][k]];
                            t = std::min(t, f[i - 1][j][o][p] + dis[j][k]);
                        }
                    }
                }
            }
        }
        for(int i = 3; i <= A.n + B.n; ++i) ans = std::min(ans, f[i][st][1][1]);
    }
    printf("%.9lf\n", ans);
	return 0;
}
// QOJ3184