#include <bits/stdc++.h>
using pdd = std::pair<long double, long double>;
using ll = long long;
long double EPS = 0.000001;

using namespace std;

struct Point {
    long double x;
    long double y;

    Point(long double a, long double b) {
        x = a;
        y = b;
    }
    Point() {

    }
};

struct Line {
    long double start_time = -1;
    long double end_time = -1;
    Point* p1 = nullptr;
    Point* p2 = nullptr;

    Line(Point* a, Point* b, long double c, long double d) {
        p1 = a;
        p2 = b;
        start_time = c;
        end_time = d;
        //cout<<start_time<<" "<<end_time<<" times\n";
    }
};

long double eucl_dist(Point* a, Point* b) {
    return sqrt((a->x - b->x)*(a->x - b->x) + (a->y - b->y)*(a->y - b->y));
}

pdd get_direction(Line* a) {
    return {(a->p2->x - a->p1->x) / eucl_dist(a->p1, a->p2), (a->p2->y - a->p1->y) / eucl_dist(a->p1, a->p2)};
}

/// find distance between point and line segment
long double calc_ans(pdd p1, pdd q1, pdd p) {
    //cout<<start_b.first<<" "<<start_b.second<<"heeee\n";
    pdd pp1 = {p.first-p1.first, p.second-p1.second};
    pdd q1p1 = {q1.first-p1.first, q1.second-p1.second};
    long double u = (pp1.first*q1p1.first + pp1.second*q1p1.second)/(q1p1.first*q1p1.first + q1p1.second*q1p1.second);
    pdd p_prime = {p1.first + u*q1p1.first, p1.second + u*q1p1.second};
    //cout<<u<<endl;
    if (u < EPS || u-1 > EPS) return 99999999;
    return sqrt((p.first-p_prime.first)*(p.first-p_prime.first) + (p.second-p_prime.second)*(p.second-p_prime.second));
}

long double calc_distance(Line* a, Line* b) {
    /// make sure a starts earlier

    if (a->start_time > b->start_time) swap(a, b);

    /// no overlap

    if (a->end_time - b->start_time <= EPS)  return 999999999;


    pdd direction_a = get_direction(a);
    pdd direction_b = get_direction(b);


    long double timer = min(a->end_time, b->end_time) - b->start_time;
    //cout<<timer<<" whar\n";



    /// positions of both dogs when dog b starts walking and their paths
    long double dif = b->start_time - a->start_time;


    //cout<<fixed<<setprecision(9)<<dif<<"\n";
    pdd start_a = {a->p1->x + dif * direction_a.first, a->p1->y + dif * direction_a.second };
    pdd start_b = {b->p1->x, b->p1->y};

    //cout<<start_a.first<<" "<<start_a.second<<" br\n";

    pdd delta_a = {direction_a.first * timer, direction_a.second * timer};
    pdd delta_b = {direction_b.first * timer, direction_b.second * timer};

    pdd end_a = {start_a.first + delta_a.first - delta_b.first, start_a.second + delta_a.second - delta_b.second};

    //cout<<"start_dist: "<<eucl_dist(new Point(start_b.first, start_b.second), new Point(start_a.first, start_a.second))<<" dist2: "<<
                           //eucl_dist(new Point(start_b.first, start_b.second), new Point(end_a.first, end_a.second))<<"\n";

    /// get minimum of distance from point to both ends of the line segment
    long double ans = min(eucl_dist(new Point(start_b.first, start_b.second), new Point(start_a.first, start_a.second)),
                           eucl_dist(new Point(start_b.first, start_b.second), new Point(end_a.first, end_a.second)));

    /// compare with shortest distance algorithm
    ans = min(ans, calc_ans(start_a, end_a, start_b));

    return ans;
}

vector<Line*> dog1;
vector<Line*> dog2;

int main() {
    /// read input for first dog path
    int n;
    cin>>n;
    Point* curr = new Point();
    cin>>curr->x>>curr->y;
    long double curr_time = 0;
    for (int i = 0; i<n-1; i++) {
        int x, y;
        cin>>x>>y;

        Point* next_point = new Point(x, y);
        long double start_t = curr_time;
        curr_time += eucl_dist(curr, next_point);
        long double end_t = curr_time;

        dog1.push_back(new Line(curr, next_point, start_t, end_t));
        curr = next_point;
    }

    /// read input for second dog path
    int m;
    cin>>m;

    Point* nc = new Point();
    cin>>nc->x>>nc->y;
    curr = nc;

    curr_time = 0;
    for (int i = 0; i<m-1; i++) {
        int x, y;
        cin>>x>>y;

         Point* next_point = new Point(x, y);
        long double start_t = curr_time;
        curr_time += eucl_dist(curr, next_point);
        long double end_t = curr_time;

        dog2.push_back(new Line(curr, next_point, start_t, end_t));
        curr = next_point;
    }

    /// two pointers on the dogs to keep track of path order
    int dog1_left = 0;
    int dog2_left = 0;
    long double ans = eucl_dist(dog1[0]->p1, dog2[0]->p1);


    while (dog1_left != dog1.size() && dog2_left != dog2.size()) {
            //cout<<ans<<"\n";
        Line* l1 = dog1[dog1_left];
        Line* l2 = dog2[dog2_left];
        long double calc = calc_distance(l1, l2);
        ans = min(ans, calc);
        if (l1->end_time < l2->end_time) dog1_left++;
        //if (l1->start_time < l2->start_time || (l1->start_time == l2->start_time && l1->end_time < l2->end_time)) dog1_left++;
        else dog2_left++;
    }

    cout<<fixed<<setprecision(9)<<ans<<"\n";
}