#include "bits/stdc++.h"

using namespace std;

using i64 = long long;

const i64 MOD = i64(1e9) + 7;
const i64 INF = i64(1e18) + 7;


template <typename T>
bool chmin(T& x, T y){
    if(x > y){
        x = y;
        return true;
    }
    return false;
}

template <typename T>
bool chmax(T& x, T y){
    if(x < y){
        x = y;
        return true;
    }
    return false;
}


namespace geometry{
    using D = long double;
    using C = complex<D>;
    constexpr D eps =1e-9;

    struct Point;
    bool near_eq(Point, Point);

    struct Point{
        D x, y;
        Point(D x = 0.0, D y = 0.0) : x(x), y(y){}
        friend bool operator<(const Point& a, const Point& b){
            return a.x == b.x ? a.y < b.y : a.x < b.x;
        }
        Point& operator+=(Point a){x += a.x, y += a.y; return *this;}
        Point& operator-=(Point a){x -= a.x, y -= a.y; return *this;}
        Point& operator*=(D p){x *= p, y *= p; return *this;}
        friend Point operator+(Point a, Point b){return Point(a) += b;}
        friend Point operator-(Point a, Point b){return Point(a) -= b;}
        friend Point operator*(Point a, Point b){return Point(a.x * b.x - a.y * b.y, a.x * b.y + b.x * a.y);}
        friend Point operator*(Point a, D p){return Point(a) *= p;}
    };
    using P = Point;
    bool near_eq(D a, D b){return abs(a - b) < eps;}
    bool near_eq(P a, P b){return near_eq(a.x, b.x) && near_eq(a.y, b.y);}
    D diag(P a){
        assert(!near_eq(a, P()));
        return atan2(a.y, a.x);
    }
    D abs_square(P a){return a.x * a.x + a.y * a.y;}
    D abs(P a){return sqrt(abs_square(a));}
    P conj(P a){return P(a.x, -a.y);}
    P norm(P a){return a * conj(a);}
    D dist(P a, P b){return abs(a - b);}
    D dot(P a, P b){return a.x * b.x + a.y * b.y;}
    D cross(P a, P b){return a.x * b.y - a.y * b.x;}
    int ccw(P a, P b, P c){
        b -= a;
        c -= a;
        if(cross(b, c) > eps)return 1;
        if(cross(b, c) < -eps)return -1;
        if(dot(b, c) < -eps)return 2;
        if(norm(b) < norm(c))return -2;
        return 0;
    }
    bool is_on_line(P a1, P a2, P b){return abs(ccw(a1, a2, b)) != -1;}
    bool is_on_segment(P a1, P a2, P b){return !ccw(a1, a2, b);}
    bool intersect(P a1, P a2, P b1, P b2){
        return ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
               ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0;
    }
    P cross_point(P a1, P a2, P b1, P b2){
        D d1 = cross(b2 - b1, b1 - a1);
        D d2 = cross(b2 - b1, a2 - a1);
        if(near_eq(d1, 0) && near_eq(d2, 0))return a1;
        assert(!near_eq(d2, 0));
        return a1 + d1 / d2 * (a2 - a1);
    }
}

using ld = long double;
using namespace geometry;

long double solve(int n, vector<ld> ax, vector<ld> ay, vector<ld> bx, vector<ld> by){
    P b1(bx[0], by[0]);
    P b2(bx[1], by[1]);
    vector<P> points;
    for(int i = 0; i < n; ++i)
        points.emplace_back(ax[i], ay[i]);

    vector<D> range(n, INF);
    range[0] = 0;
    vector<vector<D>> dist(n, vector<D>(n, INF));
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < n; ++j){
            if(i == j){
                dist[i][j] = 0;
                continue;
            }
            if(!geometry::intersect(points[i], points[j], b1, b2)){
                dist[i][j] = geometry::dist(points[i], points[j]);
            }
        }
    }
    bitset<1000> visited;
    visited.set(0);
    int idx = 0;
    for(int _ = 0; _ < n; ++_){
        int i = idx;
        D mi = INF;
        visited.set(i);
        for(int j = 0; j < n; ++j){
            if(visited[j])
                continue;
            chmin(range[j], range[i] + dist[i][j]);
            if(chmin(mi, range[j]))
                idx = j;
        }
    }
    return geometry::dist(b1, b2) + range[1];
}


signed main(){
    int n, m;
    cin >> n >> m;
    vector<ld> ax(n), ay(n), bx(m), by(m);
    for(int i = 0; i < n; ++i)
        cin >> ax[i] >> ay[i];
    for(int i = 0; i < m; ++i)
        cin >> bx[i] >> by[i];

    ld res = min(solve(n, ax, ay, bx, by), solve(m, bx, by, ax, ay));

    if(res >= 1e12){
        cout << -1 << endl;
        return 0;
    }
    printf("%.20Lf\n", res);
}



Measured memory_bytes: 18980