#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
#include <functional>
#include <queue>
#include <complex>
using namespace std;


typedef double W;

const double EPoS = 1e-8;
const W INF = 1e10;

struct edge {
	int to;
	W cost;
};
typedef pair<W, int> P;
typedef vector<vector <edge > > Graph;

void dijkstra(int s, const Graph G, vector<W>& d) {
	priority_queue< P, vector<P>, greater<P> > que;
	fill(d.begin(), d.end(), INF);
	d[s] = 0;
	que.push(P(0, s));
	while(!que.empty()) {
		P p = que.top();
		que.pop();
		int v = p.second;
		if(d[v] < p.first) continue;
		for(int i = 0; i < G[v].size(); i++) {
			edge e = G[v][i];
			if(d[e.to] > d[v] + e.cost) {
				d[e.to] = d[v] + e.cost;
				que.push(P(d[e.to], e.to));
			}
		}
	}
}

typedef complex<double> Po;
namespace std {
	bool operator < (const Po& a, const Po& b) {
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
}
double cross(const Po& a, const Po& b) {
	return imag(conj(a)*b);
}
double dot(const Po& a, const Po& b) {
	return real(conj(a)*b);
}

struct L : public vector<Po> {
	L(const Po &a, const Po &b) {
		push_back(a); push_back(b);
	}
};

int ccw(Po a, Po b, Po c) {
	b -= a; c -= a;
	if(cross(b, c) > 0)   return +1;       // counter clockwise
	if(cross(b, c) < 0)   return -1;       // clockwise
	if(dot(b, c) < 0)     return +2;       // c--a--b on line
	if(norm(b) < norm(c)) return -2;       // a--b--c on line
	return 0;
}

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 main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	int na, nb;
	cin >> na >> nb;

	vector<Po> ps[2];
	for(int i = 0; i < na; i++) {
		double x, y;
		cin >> x >> y;
		ps[0].push_back(Po(x, y));
	}
	for(int i = 0; i < nb; i++) {
		double x, y;
		cin >> x >> y;
		ps[1].push_back(Po(x, y));
	}

	double ans = INF;
	for(int loop = 0; loop < 2; loop++) {
		Graph G(na);
		double sum = 0;
		sum += abs(ps[1][0] - ps[1][1]);
		L line(ps[1][0], ps[1][1]);

		for(int i = 0; i < na; i++) {
			for(int j = i + 1; j < na; j++) {
				L l1(ps[0][i], ps[0][j]);
				if(intersectSS(line, l1)) continue;
				G[i].push_back(edge{ j, abs(ps[0][i] - ps[0][j]) });
				G[j].push_back(edge{ i, abs(ps[0][i] - ps[0][j]) });
			}
		}

		vector<W> d(na);
		dijkstra(0, G, d);
		sum += d[1];
		ans = min(ans, sum);
		swap(na, nb);
		swap(ps[0], ps[1]);
	}
	if(ans == INF) {
		cout << -1 << endl;
	}
	else {
		cout << setprecision(15) << ans << endl;
	}
}