#define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
#include <cassert>
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define all(c) begin(c), end(c)

using vi = vector<int>;
using vii = vector<vector<int>>;

using ld = long double;
using P = complex<ld>;
const ld eps = 1e-10;

ld cross(const P& a, const P& b) { return a.real()*b.imag() - a.imag()*b.real(); }
ld dot(const P& a, const P& b) { return a.real()*b.real() + a.imag()*b.imag(); }

/*
CCW

-- BEHIND -- [a -- ON -- b] --- FRONT --

CW
*/
enum { CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0 };
int ccw(P a, P b, P c) {
    b -= a; c -= a;
    if (cross(b, c) > eps)  return CCW;    // counter clockwise
    if (cross(b, c) < -eps) return CW;     // clockwise
    if (dot(b, c) < 0)      return BEHIND; // c--a--b on line
    if (norm(b) < norm(c))  return FRONT;  // a--b--c on line
    return ON;
}

struct L : public vector<P> {
    L(const P &a = 0, const P &b = 0) {
        push_back(a); push_back(b);
    }
    L(ld A, ld B, ld C) { // Ax + By + C = 0
        if (A < eps) *this = L(P(0, -C / B), P(1, -C / B));
        else if (B < eps) *this = L(P(-C / A, 0), P(-C / A, 1));
        *this = L(P(0, -C / B), P(-C / A, 0));
    }
    int ccw(const P& p) {
        return ::ccw((*this)[0], (*this)[1], p);
    }
};

bool intersectSS(const L &s, const L &t) {
    return ccw(s[0], s[1], t[0])*ccw(s[0], s[1], t[1]) <= 0 &&
        ccw(t[0], t[1], s[0])*ccw(t[0], t[1], s[1]) <= 0;
}

int na, nb;
P a[1010], b[1010];

ld solve() {
    L s(a[0], a[1]);
    ld res = 1e9;
    if (!intersectSS(s, L(b[0], b[1]))) {
        res = min(res, abs(b[0] - b[1]));
    }
    for (int i = 2; i < nb; ++i) {
        L s1(b[0], b[i]);
        L s2(b[i], b[1]);
        if (!intersectSS(s, s1) && !intersectSS(s, s2)) {
            res = min(res, abs(b[0] - b[i]) + abs(b[i] - b[1]));
        }
        for (int j = 2; j < nb; ++j) {
            if (i == j) continue;
            L s1(b[0], b[i]);
            L s2(b[i], b[j]);
            L s3(b[j], b[1]);
            if (!intersectSS(s, s1) && !intersectSS(s, s2) && !intersectSS(s, s3)) {
                res = min(res, abs(b[0] - b[i]) + abs(b[i] - b[j]) + abs(b[j] - b[1]));
            }
        }
    }
    return res + abs(a[0] - a[1]);
}

int main() {
    while (cin >> na >> nb) {
        int x, y;
        for (size_t i = 0; i < na; i++) {
            cin >> x >> y;
            a[i] = P(x, y);
        }
        for (size_t i = 0; i < nb; i++) {
            cin >> x >> y;
            b[i] = P(x, y);
        }
        
        ld ans = 1e9;
        ans = solve();
        swap(a, b);
        swap(na, nb);
        ans = min(ans, solve());
        if (ans >= 1e9) {
            puts("-1");
        } else {
            printf("%.10lf\n", (double)ans);
        }
    }
}

Measured memory_bytes: 3308