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

typedef int64_t ll;
typedef long double ld;

// O(N^3)

//#define USE_FLOATS
//#define DEBUG
//#define DEBUG_HARDER

struct vec2{
  ll x,y;

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

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

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

  ll dot(vec2 const &a)const{
    return x*a.x+y*a.y;
  }

  ll manhattan()const{
    return abs(x)+abs(y);
  }

  bool operator<(vec2 const &a)const{
    return x!=a.x? x<a.x: y<a.y;
  }

  bool operator==(vec2 const &a)const{
    return x==a.x and y==a.y;
  }

  vec2 canonical() const{
    if (x==0 and y==0) return {0,0};
    ll g=__gcd(abs(x),abs(y));
    return {x/g,y/g};
  }
};

#ifdef USE_FLOATS
typedef ld Fraction;
Fraction mf(ld a,ld b=1){return a/b;}
#else
struct Fraction{
  ll n,d;

  Fraction():n(0),d(1){}

  Fraction(ll n, ll d):n(n),d(d){
    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),d);
    n/=g, d/=g;
  }

  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;
  }

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

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

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

  explicit operator ld() const{
    return n/(ld)d;
  }
};

Fraction mf(ll a,ll b=1){return Fraction(a,b);}
#endif

/*
 * If the line (a,a+fd) intersects the ray (b,b+bd), this returns a pair of:
 *
 *   - intersect_point: the unique coordinate of the intersection
 *
 *   - intersect_side: false if the line crosses the ray "left-to-right" (exiting a shape bounded
 *                     by it), true if crossing "right-to-left" (entering a shape bounded by it).
 *                     This assumes the ray is part of a CCW-specified polygon.
 *
 * If the line does not intersect the ray or line and ray are colinear, this returns nullopt.
 */
optional<pair<Fraction,bool>> line_ray(vec2 a,vec2 ad,vec2 b,vec2 bd){
  vec2 const d=(b-a);

  // det = 0 (lines are parallel)
  ll const det=ad*bd;
  if (det==0) return nullopt;

  // ld const u=(d*bd)/(ld)det;
  // ld const v=(d*ad)/(ld)det;
  Fraction const u=mf(d*bd,det);
  Fraction const v=mf(d*ad,det);

  // u < 0 (negative extrapolation)
  if (signbit(d*bd)!=signbit(det)) return nullopt;

  if (v<mf(0)) return nullopt; // v<0 means lines intersect before ray
  if (v>mf(1)) return nullopt; // v>1 means lines intersect after ray

  return make_pair(u, det>0);
}

vector<pair<Fraction,Fraction>> extrapolate(vec2 s, vec2 t, vector<vec2> const &h){
  vector<pair<Fraction,bool>> events;
  for (int i=0,j=h.size()-1; i<h.size(); j=i++){
    auto ans=line_ray(s,t,h[j],h[i]-h[j]);
    if (ans){
      events.emplace_back(*ans);
    }else{
      // Colinear edges: we'll count the entire edge as a contained interval, which will cause
      // problems later, unless we hack something to prevent that (see below for hack)
      if (t*h[i]==0 and t*h[j]==0 and t.dot(h[i])>0){
        Fraction u=mf(h[i].manhattan(),t.manhattan());
        Fraction v=mf(h[j].manhattan(),t.manhattan());
        if (v<u) swap(u,v);
        events.emplace_back(u,false);
        events.emplace_back(v,true);
      }
    }
  }
  sort(events.begin(),events.end());

  // Merge together repeated or immediately-contradicting eventss. This is a hack to work around
  // the sloppy line-polygon tests that can create mismatched intervals.
  {
    int j=0;
    for (int i=0; i<events.size(); i++){
      if (i+1<events.size() and events[i]==events[i+1]){
        continue;
      }
      else if (i+1<events.size() and (events[i].second%2) != (j%2) and events[i].first==events[i+1].first){
        swap(events[i],events[i+1]);
        events[j++]=events[i];
      }
      else{
        events[j++]=events[i];
      }
    }
    while (events.size()>j) events.pop_back();
  }

  #ifdef DEBUG_HARDER
  cerr<<"!! ";
  for (auto i: events) cerr<<"  ("<<(ld)(i.first)<<" | "<<i.second<<")";
  cerr<<endl;
  #endif

  #ifdef DEBUG
  for (int i=0; i<events.size(); i++){
    assert(events[i].second%2 == i%2);
  }
  assert((events.size()%2)==1);
  #endif

  vector<pair<Fraction,Fraction>> legal;
  for (int i=0,j=-1; i<events.size(); i++){
    if (events[i].second==false and (i==0 or events[i-1].second!=false)){
      // closing
      if (i==0){
        legal.emplace_back(mf(0,1),events[i].first);
      }else{
        legal.emplace_back(events[i-1].first,events[i].first);
      }
    }else{
      // opening
      j=i;
    }
  }

  #ifdef DEBUG
  cerr<<"-";
  for (auto i: legal) cerr<<"  ("<<(ld)(i.first)<<","<<(ld)(i.second)<<")";
  cerr<<endl;
  #endif

  return legal;
}

ll areaX2(vector<vec2> const &v){
  ll total=0;
  for (int i=0,j=v.size()-1; i<v.size(); j=i++){
    total+=v[i]*v[j];
  }
  return total;
}

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

  // Find interestings direction using the vertices of both shapes.
  set<vec2> directions;
  for (auto const &i: pa){
    directions.insert(i.canonical());
  }
  for (auto const &i: pb){
    directions.insert(i.canonical());
  }

  // This is the range of sizes that "match", per direction.
  vector<vector<pair<Fraction,Fraction>>> constraints;

  // For each direction, project outwards through both shapes.
  for (auto const &d: directions){   // O(N+M)
    #ifdef DEBUG
    cerr<<endl<<"dirn="<<d.x<<" "<<d.y<<endl;
    #endif

    auto ra=extrapolate({0,0},d,pa); // O(NlogN)
    auto rb=extrapolate({0,0},d,pb); // O(MlogM)

    #ifdef DEBUG
    cerr<<"intersections A:";
    for (auto it: ra) cerr<<" ("<<(ld)it.first<<" "<<(ld)it.second<<")"; cerr<<endl;
    cerr<<"intersections B:";
    for (auto it: rb) cerr<<" ("<<(ld)it.first<<" "<<(ld)it.second<<")"; cerr<<endl;
    #endif

    for (auto const &i: ra){ // O(N)
      constraints.emplace_back();
      for (auto const &j: rb){ // O(M)
        auto const hi=j.second/i.second;
        auto const lo=(j.first==mf(0) and i.first==mf(0)? mf(0): j.first/i.first);
        if (not (lo>hi)){
          constraints.back().emplace_back(lo,hi);
        }
      }
      #ifdef DEBUG_HARDER
      cerr<<"constraints: ";
      for (auto j: constraints.back()){
        cerr<<"  ["<<(ld)j.first<<" "<<(ld)j.second<<"]";
      }
      cerr<<endl;
      #endif
    }
  }

  // March through all of the constraints we just generated, looking for regions
  // where all of the constraints are satisifed at once. Report the biggest.
  vector<tuple<Fraction,bool,int>> events;
  for (int i=0; i<constraints.size(); i++){
    for (int j=0; j<constraints[i].size(); j++){
      if(j && get<0>(events.back()) == constraints[i][j].first)
        get<0>(events.back()) = constraints[i][j].second;
      else {
        events.emplace_back(constraints[i][j].first,0,i);
        events.emplace_back(constraints[i][j].second,1,i);
      }
    }
  }
  sort(events.begin(),events.end());

  ld best=-1L;
  int satisfied=0;
  vector<bool> active(constraints.size());

  for (auto evt: events){
    if (satisfied==constraints.size()){
      best=(ld)(get<0>(evt));
    }
    if (get<1>(evt)==0){
      ++satisfied;
      assert(not active[get<2>(evt)]);
      active[get<2>(evt)]=true;
    }else{
      --satisfied;
      assert(active[get<2>(evt)]);
      active[get<2>(evt)]=false;
    }
  }

  cout.precision(20);
  cout<<best<<endl;
}