#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#define NDEBUG
#define SHOW(...) static_cast<void>(0)
//!===========================================================!//
//!  dP     dP                          dP                    !//
//!  88     88                          88                    !//
//!  88aaaaa88a .d8888b. .d8888b. .d888b88 .d8888b. 88d888b.  !//
//!  88     88  88ooood8 88'  '88 88'  '88 88ooood8 88'  '88  !//
//!  88     88  88.  ... 88.  .88 88.  .88 88.  ... 88        !//
//!  dP     dP  '88888P' '88888P8 '88888P8 '88888P' dP        !//
//!===========================================================!//
template <typename T>
T read()
{
    T v;
    return std::cin >> v, v;
}
template <typename T>
std::vector<T> readVec(const std::size_t l)
{
    std::vector<T> v(l);
    for (auto& e : v) { std::cin >> e; }
    return v;
}
using ld = long double;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr unsigned int MOD = 1000000007;
template <typename T>
constexpr T INF = std::numeric_limits<T>::max() / 4;
template <typename F>
constexpr F PI = static_cast<F>(3.1415926535897932385);
std::mt19937 mt{std::random_device{}()};
template <typename T>
bool chmin(T& a, const T& b) { return (a > b ? a = b, true : false); }
template <typename T>
bool chmax(T& a, const T& b) { return (a < b ? a = b, true : false); }
template <typename T>
std::vector<T> Vec(const std::size_t n, T v) { return std::vector<T>(n, v); }
template <class... Args>
auto Vec(const std::size_t n, Args... args) { return std::vector<decltype(Vec(args...))>(n, Vec(args...)); }
template <typename T>
constexpr T popCount(const T u)
{
#ifdef __has_builtin
    return u == 0 ? T(0) : (T)__builtin_popcountll(u);
#else
    unsigned long long v = static_cast<unsigned long long>(u);
    return v = (v & 0x5555555555555555ULL) + (v >> 1 & 0x5555555555555555ULL), v = (v & 0x3333333333333333ULL) + (v >> 2 & 0x3333333333333333ULL), v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL, static_cast<T>(v * 0x0101010101010101ULL >> 56 & 0x7f);
#endif
}
template <typename T>
constexpr T log2p1(const T u)
{
#ifdef __has_builtin
    return u == 0 ? T(0) : T(64 - __builtin_clzll(u));
#else
    unsigned long long v = static_cast<unsigned long long>(u);
    return v = static_cast<unsigned long long>(v), v |= (v >> 1), v |= (v >> 2), v |= (v >> 4), v |= (v >> 8), v |= (v >> 16), v |= (v >> 32), popCount(v);
#endif
}
template <typename T>
constexpr T clog(const T v) { return v == 0 ? T(0) : log2p1(v - 1); }
template <typename T>
constexpr T msbp1(const T v) { return log2p1(v); }
template <typename T>
constexpr T lsbp1(const T v)
{
#ifdef __has_builtin
    return __builtin_ffsll(v);
#else
    return v == 0 ? T(0) : popCount((v & (-v)) - T(1)) + T(1);
#endif
}
template <typename T>
constexpr bool ispow2(const T v) { return popCount(v) == 1; }
template <typename T>
constexpr T ceil2(const T v) { return v == 0 ? T(1) : T(1) << log2p1(v - 1); }
template <typename T>
constexpr T floor2(const T v) { return v == 0 ? T(0) : T(1) << (log2p1(v) - 1); }
//!=======================================================================================!//
//!   a88888b.                     dP       .88888.                             dP        !//
//!  d8'   '88                     88      d8'   '88                            88        !//
//!  88        .d8888b. .d8888b. d8888P    88        88d888b. .d8888b. 88d888b. 88d888b.  !//
//!  88        88'  '88 Y8ooooo.   88      88   YP88 88'  '88 88'  '88 88'  '88 88'  '88  !//
//!  Y8.   .88 88.  .88       88   88      Y8.   .88 88       88.  .88 88.  .88 88    88  !//
//!   Y88888P' '88888P' '88888P'   dP       '88888'  dP       '88888P8 88Y888P' dP    dP  !//
//!                                                                    88                 !//
//!                                                                    dP                 !//
//!=======================================================================================!//
template <typename Cost>
struct CostGraph
{
    CostGraph(const std::size_t v) : V{v}, edge(v), rev_edge(v) {}
    void addEdge(const std::size_t from, const std::size_t to, const Cost cost, const bool bi = false)
    {
        assert(from < V), assert(to < V);
        edge[from].push_back(Edge{to, cost}), rev_edge[to].push_back(Edge(from, cost));
        if (bi) { addEdge(to, from, cost, false); }
    }
    struct Edge
    {
        Edge(const std::size_t to, const Cost cost) : to{to}, cost{cost} {}
        const std::size_t to;
        const Cost cost;
        bool operator<(const Edge& e) const { return cost != e.cost ? cost < e.cost : to < e.to; }
    };
    const std::vector<Edge>& operator[](const std::size_t i) const { return assert(i < V), edge[i]; }
    friend std::ostream& operator<<(std::ostream& os, const CostGraph& g)
    {
        os << "[\n";
        for (std::size_t i = 0; i < g.V; i++) {
            for (const auto& e : g.edge[i]) { os << i << "->" << e.to << ":" << e.cost << "\n"; }
        }
        return (os << "]\n");
    }
    const std::size_t V;
    std::vector<std::vector<Edge>> edge, rev_edge;
};
template <typename Cost>
using CostTree = CostGraph<Cost>;
//!=====================================!//
//!  8888ba.88ba           oo           !//
//!  88  '8b  '8b                       !//
//!  88   88   88 .d8888b. dP 88d888b.  !//
//!  88   88   88 88'  '88 88 88'  '88  !//
//!  88   88   88 88.  .88 88 88    88  !//
//!  dP   dP   dP '88888P8 dP dP    dP  !//
//!=====================================!//
int main()
{
    struct CostGraph
    {
        CostGraph(const std::size_t v) : V{v}, edge(v) {}
        void addEdge(const std::size_t from, const std::size_t to, const ld cost) { edge[from].push_back(Edge{to, cost}), edge[to].push_back(Edge{from, cost}); }
        struct Edge
        {
            Edge(const std::size_t to, const ld cost) : to{to}, cost{cost} {}
            const std::size_t to;
            const ld cost;
            bool operator<(const Edge& e) const { return cost != e.cost ? cost < e.cost : to < e.to; }
        };
        const std::vector<Edge>& operator[](const std::size_t i) const { return edge[i]; }
        const std::size_t V;
        std::vector<std::vector<Edge>> edge;
    };
    const int NA = read<int>(), NB = read<int>();
    std::vector<int> xa(NA), ya(NA);
    for (int i = 0; i < NA; i++) { std::cin >> xa[i] >> ya[i]; }
    CostGraph GA(NA);
    std::vector<int> xb(NB), yb(NB);
    for (int i = 0; i < NB; i++) { std::cin >> xb[i] >> yb[i]; }
    CostGraph GB(NB);
    const int ax = xa[0], ay = ya[0], bx = xa[1], by = ya[1];
    const int cx = xb[0], cy = yb[0], dx = xb[1], dy = yb[1];
    const ld la = std::hypot(ax - bx, ay - by), lb = std::hypot(cx - dx, cy - dy);
    auto cross = [&](const ll ax, const ll ay, const ll bx, const ll by, const ll cx, const ll cy, const ll dx, const ll dy) {
        const ll ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
        const ll tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
        const ll tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
        const ll td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
        return ta * tb < 0 and tc * td < 0;
    };
    for (int i = 0; i < NA; i++) {
        for (int j = i + 1; j < NA; j++) {
            if (cross(xa[i], ya[i], xa[j], ya[j], cx, cy, dx, dy)) { continue; }
            GA.addEdge(i, j, std::hypot(xa[i] - xa[j], ya[i] - ya[j]));
        }
    }
    for (int i = 0; i < NB; i++) {
        for (int j = i + 1; j < NB; j++) {
            if (cross(xb[i], yb[i], xb[j], yb[j], ax, ay, bx, by)) { continue; }
            GB.addEdge(i, j, std::hypot(xb[i] - xb[j], yb[i] - yb[j]));
        }
    }
    constexpr ld INF = 4e7;
    auto Dijkstra = [&](const CostGraph& g, const std::size_t s) {
        std::vector<ld> d(g.V, INF);
        using P = std::pair<ld, std::size_t>;
        std::priority_queue<P, std::vector<P>, std::greater<P>> q;
        d[s] = 0, q.push({0, s});
        while (not q.empty()) {
            const ld cost = q.top().first;
            const std::size_t v = q.top().second;
            q.pop();
            if (d[v] < cost) { continue; }
            for (const auto& e : g.edge[v]) {
                if (d[e.to] <= d[v] + e.cost) { continue; }
                d[e.to] = d[v] + e.cost, q.push({d[e.to], e.to});
            }
        }
        return d;
    };
    const auto cla = Dijkstra(GA, 0);
    const auto clb = Dijkstra(GB, 0);
    const ld ans = std::min(cla[1] + lb, clb[1] + la);
    if (ans >= INF) {
        std::cout << -1 << std::endl;
    } else {
        std::cout << std::fixed << std::setprecision(12) << ans << std::endl;
    }
    return 0;
}



Measured memory_bytes: 70116