#include <bits/stdc++.h>
using namespace std;

typedef int64_t ll;
typedef long double ld;

#define USE_FLOATS

#ifdef USE_FLOATS
typedef __float128 Fraction;
#else
struct Fraction{
  __int128 n,d;

  Fraction(ll n=0, ll d=1):n(n),d(d){
    if (n) simplify();
  }

  Fraction(const Fraction &other): n(other.n), d(other.d){}

  void simplify(){
    if (d<0) n=-n, d=-d;
    if (n==0) d=1;
    ll const g=__gcd(abs(n),abs(d));
    assert(g!=0);
    n/=g, d/=g;
  }

  Fraction operator+(Fraction const &a)const{
    return Fraction{n*a.d+a.n*d,d*a.d};
  }

  Fraction operator-(Fraction const &a)const{
    return Fraction{n*a.d-a.n*d,d*a.d};
  }

  Fraction operator-()const{
    return Fraction{-n,d};
  }

  Fraction &operator+=(Fraction const &a){
    n=n*a.d+a.n*a.d;
    d*=a.d;
    simplify();
    return *this;
  }

  Fraction &operator-=(Fraction const &a){
    n=n*a.d-a.n*a.d;
    d*=a.d;
    simplify();
    return *this;
  }

  Fraction operator*(Fraction const &a)const{
    return {n*a.n,d*a.d};
  }

  Fraction operator/(Fraction const &a)const{
    return {n*a.d*(a.n<0?-1:1),d*abs(a.n)};
  }

  Fraction &operator*=(Fraction const &a){
    n*=a.n;
    d*=a.d;
    simplify();
    return *this;
  }

  Fraction &operator/=(Fraction const &a){
    n*=(a.n<0?-a.d:a.d);
    d*=abs(a.n);
    simplify();
    return *this;
  }

  bool operator==(Fraction const &a)const{
    if (n==0 or a.n==0) return n==0 and a.n==0;
    return n*a.d==a.n*d;
  }

  bool operator<(Fraction const &a)const{
    return n*a.d<a.n*d;
  }

  bool operator<=(Fraction const &a)const{
    return n*a.d<=a.n*d;
  }

  bool operator>(Fraction const &a)const{
    return n*a.d>a.n*d;
  }

  bool operator>=(Fraction const &a)const{
    return n*a.d>=a.n*d;
  }

  bool operator<(ll const &a)const{
    return n<a*d;
  }

  bool operator>(ll const &a)const{
    return n>a*d;
  }

  bool operator<=(ll const &a)const{
    return n<=a*d;
  }

  bool operator>=(ll const &a)const{
    return n>=a*d;
  }

  bool operator==(ll const &a)const{
    return n==a*d;
  }

  ld evaluate() const{
    return n/(ld)d;
  }

  explicit operator ll() const{
    assert(d==1);
    return n;
  }

  explicit operator ld() const{
    return evaluate();
  }
};
#endif

struct vec2{
  Fraction x,y;

  vec2 operator-(vec2 const &a)const{
    return {x-a.x,y-a.y};
  }

  vec2 operator -()const{
    return {-x,-y};
  }

  vec2 operator *(Fraction const f)const{
    return {x*y,y*f};
  };

  vec2 &operator *=(Fraction const f){
    x*=f; y*=f;
    return *this;
  }

  Fraction operator ^(vec2 const &a)const{
    return (y*a.x)-(x*a.y);
  }
};

ll areaX2(vector<vec2> const &v){
  Fraction total=0;
  for (int i=0,j=v.size()-1; i<v.size(); j=i++){
    total+=(ll)(v[i]^v[j]);
  }
  #ifdef USE_FLOATS
  return total;
  #else
  assert(total.d==1);
  return total.n;
  #endif
}

vector<Fraction> find_intersections(vec2 const &v,vector<vec2> const &b){
  vector<Fraction> res;
  for (int i=0,j=b.size()-1; i!=b.size(); j=i++){
    if ((v^b[i])*(v^b[j])<=0){
      vec2 b1=b[i];
      vec2 bd=b[j]-b[i];
      if ((bd^v)==0) continue;
      // v*f = b1 + bd*g
      // vx*f = b1x + bdx*g
      // vy*f = b1y + bdy*g
      //
      // bdy*vx*f - bdx*vy*f = b1x*bdy - b1y*bdx
      // (bd^v)*f = (bd^b)
      // f = (bd^b1)/(bd^v)
      Fraction f = (bd^b1)/(bd^v);
      if (f==0){
        continue;
      }
      if (f>0){
        res.push_back(f);
      }
    }
  }
  return res;
}

Fraction interpolate(vec2 a,vec2 b,Fraction x){
  vec2 ab=(b-a);
  return a.y+ab.y*(x-a.x)/ab.x;
}

vector<pair<Fraction,Fraction>> vertical_slice(vector<vec2> const &p,Fraction const x){
  vector<Fraction> opens,closes;
  for (int c=0,b=p.size()-1,a=p.size()-2; c<p.size(); a=b, b=c++){
    if (p[b].x<x){
      if (p[a].x>x){
        // going left = roof
        closes.push_back(interpolate(p[a],p[b],x));
      }
    }
    else if (p[b].x>x){
      if (p[a].x<x){
        // going right = ground
        opens.push_back(interpolate(p[a],p[b],x));
      }
    }
    else if (p[b].x==x){
      if ((p[a].x>x and p[c].x>x) or (p[a].x<x and p[c].x<x)){
        // elbow = single point
        opens.push_back(p[b].y);
        closes.push_back(p[b].y);
      }
      else if (p[a].x==x and p[c].x==x){
        // middle of a line
      }
      else if (p[c].x==x){
        // start of a vertical segment
        if (p[c].y<p[b].y and p[b].x<p[a].x){
          // transition down wall from roof
          closes.push_back(p[b].y);
        }
        else if (p[c].y>p[b].y and p[b].x>p[a].x){
          // transition up wall from floor
          opens.push_back(p[b].y);
        }
      }
      else if (p[a].x==x){
        // end of a vertical segment
        if (p[a].y<p[b].y and p[c].x<p[b].x){
          // transition from up wall to roof
          closes.push_back(p[b].y);
        }
        else if (p[a].y>p[b].y and p[c].x>p[b].x){
          // transition from down wall to floor
          opens.push_back(p[b].y);
        }
      }
      else if (p[a].x>x and p[c].x<x) {
        // going left = roof
        closes.push_back(p[b].y);
      }
      else if (p[a].x<x and p[c].x>x){
        // going right = ground
        opens.push_back(p[b].y);
      }
    }
  }
  sort(opens.begin(),opens.end());
  sort(closes.begin(),closes.end());
  assert(opens.size()==closes.size());

  vector<pair<Fraction,Fraction>> regions;
  for (int i=0,j=1; i<opens.size(); i=j++){
    while (j<opens.size() and opens[j]<=closes[i]) ++j;
    regions.emplace_back(opens[i],closes[j-1]);
  }
  return regions;
}

bool fully_contained(vector<vec2> const &a,vector<vec2> const &b,bool plog){
  vector<Fraction> key_x;
  for (auto i: a) key_x.push_back(i.x);
  for (auto i: b) key_x.push_back(i.x);
  sort(key_x.begin(),key_x.end());
  for (int i=key_x.size()-1; i-->0;) key_x.push_back((key_x[i]+key_x[i+1])/2.0L);
  sort(key_x.begin(),key_x.end());

  Fraction lx{-1};
  for (auto const &x: key_x){
    if (x==lx) continue; else lx=x;

    vector<pair<Fraction,Fraction>> outer=vertical_slice(b,x);
    vector<pair<Fraction,Fraction>> inner=vertical_slice(a,x);
    if (plog){
      cerr<<" consider "<<(long double)(x)<<endl;
      cerr<<"   inner:"; for (auto i: inner) cerr<<"  {"<<(long double)(i.first)<<" "<<(long double)(i.second)<<"}"; cerr<<endl;
      cerr<<"   outer:"; for (auto i: outer) cerr<<"  {"<<(long double)(i.first)<<" "<<(long double)(i.second)<<"}"; cerr<<endl;
    }
    for (int i=0,j=0; i<inner.size(); i++){
      while (j<outer.size() and outer[j].second<inner[i].second) ++j;
      if (j==outer.size()) return false;
      if (outer[j].first>inner[i].first or outer[j].second<inner[i].second) return false;
    }
  }
  if (plog) cerr<<" passed"<<endl;
  return true;
}

int main(){
  cout.precision(10);
  cerr.precision(16);

  // Take in the polygons and fix the winding order as anticlockwise
  int n; cin>>n; vector<vec2> pa(n); for (auto &i: pa) {long double x,y; cin>>x>>y; i={x,y};}
  int m; cin>>m; vector<vec2> pb(m); for (auto &i: pb) {long double x,y; cin>>x>>y; i={x,y};}
  if (areaX2(pa)<0) reverse(pa.begin(),pa.end());
  if (areaX2(pb)<0) reverse(pb.begin(),pb.end());

  // Compute the scaling factors at which a vertex of one shape touches
  // an edge of another shape.
  vector<Fraction> boundaries;
  for (int i=0; i<n; i++){
    for (auto j: find_intersections(pa[i],pb)){
      boundaries.push_back(j);
    }
  }
  for (int i=0; i<m; i++){
    for (auto j: find_intersections(pb[i],pa)){
      boundaries.push_back(Fraction{1}/j);
    }
  }
  sort(boundaries.rbegin(),boundaries.rend());

  // Apply every scale factor from largest-to-smallest until one works.
  Fraction lsf=-1;
  for (auto const sf: boundaries){
    if (sf==lsf) continue; else lsf=sf;

    vector<vec2> pa2=pa;
    for (auto &i: pa2) i*=sf;

    bool plog=(abs((ld)(sf)-2.4921793253597721482)<1e-10L);
    if (plog) cerr<<"trying "<<(long double)(sf)<<endl;

    if (fully_contained(pa2,pb,plog)){
      cout<<fixed<<(long double)(sf)<<endl;
      return 0;
    }
  }
  cout<<"0"<<endl;
  return 0;
}