//2016 ACM-ICPC World Finals Problem. H
//O(n^4 log n)
//Extremely hard to code!!!
#include<bits/stdc++.h>
using namespace std;

#define ld double
#define eps 1e-5
struct vec{
	ld x , y; vec(ld _x = 0 , ld _y = 0) : x(_x) , y(_y){}
	friend vec operator +(vec p , vec q){return vec(p.x + q.x , p.y + q.y);}
	friend vec operator -(vec p , vec q){return vec(p.x - q.x , p.y - q.y);}
	friend ld operator *(vec p , vec q){return p.x * q.x + p.y * q.y;}
	friend ld operator %(vec p , vec q){return p.x * q.y - p.y * q.x;}
	friend vec rot(vec x , ld a){return vec(x.x * cos(a) - x.y * sin(a) , x.x * sin(a) + x.y * cos(a));}
	friend ld ang(vec p){return atan2(p.y , p.x);}
	friend ld len(vec p){return sqrt(p.x * p.x + p.y * p.y);}
	friend bool operator <(vec p , vec q){return fabs(p.y - q.y) < eps ? p.x < q.x : p.y < q.y;}
}A[53] , B[53] , TA[53] , TB[53]; int NA , NB;

struct line{
	vec s , t; ld ag; line(vec _s = vec() , vec _t = vec() , bool f = 0) : s(_s) , t(_t){if(f) ag = ang(_t - _s);}
	friend bool truesect(line p , line q){
		if(((q.t - p.s) % (p.t - p.s)) * ((q.s - p.s) % (p.t - p.s)) > -eps) return 0;
		swap(p , q); if(((q.t - p.s) % (p.t - p.s)) * ((q.s - p.s) % (p.t - p.s)) > -eps) return 0;
		return 1;
	}
};

ld move(vec s , vec t , vec q){return (fabs(s.x - t.x) < eps ? s.x : s.x + (q.y - s.y) / (t.y - s.y) * (t.x - s.x)) - q.x;}

int p , q , r , sz; bool vis[53];
int nxt(int x){while(vis[(x - 1) % sz + 1]) ++x; return (x - 1) % sz + 1;}
bool check(vec *v){
	bool f = (v[r] - v[q]) % (v[q] - v[p]) > -eps;
	for(int i = 1 ; i <= sz ; ++i){
		f &= (v[i] - v[p]) % (v[q] - v[p]) < eps || (v[i] - v[q]) % (v[r] - v[q]) < eps || (v[i] - v[r]) % (v[p] - v[r]) < eps;
	}
	int x = nxt(1) , y = nxt(x + 1) , pre = x;
	do{
		f &= !truesect(line(v[x] , v[y]) , line(v[p] , v[r]));
		x = y; y = nxt(y + 1);
	}while(x != pre);
	return !f;
}
struct tri{vec x[3]; vec& operator [](int p){return x[p];}}; vector < tri > trA , trB;

vector < tri > prepare_triangulation(vec *v , int sz){
	vector < tri > tmp; p = 1; q = 2; r = 3; ::sz = sz; memset(vis , 0 , sizeof(vis));
	for(int i = 1 ; i <= sz - 2 ; ++i){
		while(check(v)){p = q; q = r; r = nxt(r + 1);}
		tmp.push_back((tri){v[p] , v[q] , v[r]}); vis[q] = 1; q = r; r = nxt(r + 1);
	}
	return tmp;
}

struct dat{ld pos , inc1 , inc2;}; ld ans;
bool operator <(dat p , dat q){if(fabs(p.pos - q.pos) < eps){return p.inc2 > q.inc2;} return p.pos < q.pos;}

void work(ld agp , ld agq , ld dlty){
	vector < dat > pot; ld lsum = 0;
	for(int k = 1 ; k <= NA + 1 ; ++k) TA[k] = rot(A[k] , -agp);
	for(int k = 1 ; k <= NB + 1 ; ++k) TB[k] = rot(B[k] , -agq) - vec(0 , dlty);
	
	for(int k = 1 ; k <= NA ; ++k)
		for(int l = 1 ; l <= NB ; ++l){
			vec xa = TA[k] , xb = TA[k + 1] , ya = TB[l] , yb = TB[l + 1] , x = xb - xa , y = yb - ya;
			if(fabs(x % y) < eps)
				if(fabs(x.y) < eps){
					if(fabs(xa.y - ya.y) > eps) continue;
					if(x.x < 0){swap(xa , xb); x.x = -x.x;} if(y.x < 0){swap(ya , yb); y.x = -y.x;}
					ld minl = min(x.x , y.x); lsum += minl;
					pot.push_back((dat){ya.x - xb.x , 1 , 0}); pot.push_back((dat){ya.x - xb.x + minl , -1 , 0});
					pot.push_back((dat){yb.x - xa.x , 1 , 0}); pot.push_back((dat){yb.x - xa.x - minl , -1 , 0});
				}else{
					ld dlt = move(ya , yb , xa); xa.x += dlt; xb.x += dlt;
					if(x.y < 0){swap(xa , xb);} if(y.y < 0){swap(ya , yb);}
					ld l = max((ld)0 , min(xb.y , yb.y) - max(xa.y , ya.y)) / fabs(x.y) * len(x); lsum += l;
					pot.push_back((dat){dlt , 0 , l}); pot.push_back((dat){dlt , 0 , -l});
				}
		}
	
	vector < tri > tA = trA , tB = trB;
	for(auto &x : tA) for(int i = 0 ; i < 3 ; ++i) x[i] = rot(x[i] , -agp);
	for(auto &x : tB) for(int i = 0 ; i < 3 ; ++i) x[i] = rot(x[i] , -agq) - vec(0 , dlty);

	vector < dat > pt1;
	for(auto l : tA){
		for(int i = 0 ; i < 3 ; ++i){l[i].x = -l[i].x; l[i].y = -l[i].y;}
		int mxl = 0; for(int i = 0 ; i < 3 ; ++i) if(l[mxl] < l[i]) mxl = i;
		for(int i = 0 ; i < mxl ; ++i){swap(l[0] , l[2]); swap(l[0] , l[1]);}
		for(auto r : tB){
			int mxr = 0; for(int i = 0 ; i < 3 ; ++i) if(r[mxr] < r[i]) mxr = i;
			for(int i = 0 ; i < mxr ; ++i){swap(r[0] , r[2]); swap(r[0] , r[1]);}
			vec fir = l[0] + r[0]; int pl = 0 , pr = 0; vector < ld > pt; bool f1 = 0 , f2 = 0;
			while(pl < 3 || pr < 3){
				vec nw;
				if(pr == 3 || (pl < 3 && (l[(pl + 1) % 3] - l[pl]) % (r[(pr + 1) % 3] - r[pr]) <= 0)){
					nw = fir + (l[(pl + 1) % 3] - l[pl]); ++pl;
				}else{nw = fir + (r[(pr + 1) % 3] - r[pr]); ++pr;}
				if(nw.y * fir.y <= eps) pt.push_back(fabs(nw.y - fir.y) < eps ? nw.x : nw.x + -nw.y / (fir.y - nw.y) * (fir.x - nw.x));
				fir = nw; f1 |= nw.y > eps; f2 |= nw.y < -eps;
			}
			sort(pt.begin() , pt.end());
			if(f1 && f2 && pt.size() >= 2 && pt.back() - pt[0] > eps){
				pt1.push_back((dat){pt[0] , 0 , -1}); pt1.push_back((dat){pt.back() , 0 , 1});
			}
		}
	}

	sort(pt1.begin() , pt1.end()); sort(pot.begin() , pot.end()); ld v1 = 0 , v2 = 0; int cnt = 0 , p1 = 0 , pt = 0;
	while(pt < pot.size()){
		ld cur = min(pot[pt].pos , p1 < pt1.size() ? pt1[p1].pos : 1e18);
		bool f = !cnt; while(p1 < pt1.size() && pt1[p1].pos < cur + eps) f |= !(cnt += pt1[p1++].inc2);
		if(f){ans = max(ans , v1 * cur + v2);}
		while(pt < pot.size() && fabs(pot[pt].pos - cur) < eps){
			dat t = pot[pt++]; v2 += t.inc2; v1 += t.inc1; v2 += -t.inc1 * t.pos;
			if(f){ans = max(ans , v1 * t.pos + v2);}
		}
	}
}

int main(){
	cin >> NA; for(int i = 1 ; i <= NA ; ++i) cin >> A[i].x >> A[i].y;
	cin >> NB; for(int i = 1 ; i <= NB ; ++i) cin >> B[i].x >> B[i].y;
	assert(std::max(NA,NB)<=3);
	A[NA + 1] =A[1]; B[NB + 1] = B[1]; trA = prepare_triangulation(A , NA); trB = prepare_triangulation(B , NB);
	for(int i = 1 ; i <= NA ; ++i)
		for(int j = 1 ; j <= NB ; ++j){
			ld agp = ang(A[i + 1] - A[i]) , agq = ang(B[j + 1] - B[j]);
			work(agp , agq , rot(B[j] , -agq).y - rot(A[i] , -agp).y);
			work(agp , agq + acos(-1) , rot(B[j] , -agq - acos(-1)).y - rot(A[i] , -agp).y);
		}
	cout << fixed << setprecision(4) << ans; return 0;
}