#include <iostream>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <algorithm>
using namespace std;

typedef complex<double> P;
struct L : public vector<P>
{
	L(P a, P b) { push_back(a); push_back(b); }
};


#define EPS			(1e-10)
#define PI			(3.14159265358979323846)
#define INF			1e30

#define X(a)		( (a).real() )
#define Y(a)		( (a).imag() )
#define EQ(a,b)		( -EPS<(a)-(b) && (a)-(b)<EPS )
#define EQV(a,b)	( EQ(X(a),X(b)) && EQ(Y(a),Y(b)) )

#define unit(a)		( (a)/abs(a) )
#define normal(a)	( (a)*P(0,1) )
#define dot(a,b)	( X((a)*conj(b)) )
#define cross(a,b)	( Y(conj(a)*(b)) )

int ccw(P a, P b, P 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(P a, P b, P c, P d)
{
	return	ccw(a,b,c)*ccw(a,b,d) <= 0 &&
			ccw(c,d,a)*ccw(c,d,b) <= 0;
}

double graph[1000][1000];

void makeGraph(vector<P>& towns, P a, P b)
{
	for(int i=0; i<towns.size(); i++)
	for(int j=i+1; j<towns.size(); j++)
	{
		graph[i][j] = graph[j][i] = graph[i][i] = graph[j][j] = INF;
		if(intersectSS(towns[i], towns[j], a,b)) continue;
		graph[i][j] = graph[j][i] = abs(towns[i] - towns[j]);
	}
}

class State
{
public:
	int n;
	double c;
	State(int n, double c)
		:n(n),c(c)
	{}

	bool operator<(const State& s) const
	{
		return c>s.c;
	}
};

double dijkstra(int N)
{
	priority_queue<State> q;
	q.push(State(0,0));

	bool visited[1000] = {0};

	while(!q.empty()) {
		State s = q.top(); q.pop();
		if(s.n == 1) return s.c;

		if(visited[s.n]) continue;
		visited[s.n] = true;

		for(int i=0; i<N; i++) {
			if(graph[s.n][i] == INF) continue;
			if(visited[i]) continue;

			q.push(State(i,s.c+graph[s.n][i]));
		}
	}
	return INF;
}

void solve(vector<P>& totata, vector<P>& tutete)
{
	double res = INF;
	for(int i=0; i<2; i++) {
		makeGraph(totata, tutete[0], tutete[1]);
		res = min(res, dijkstra(totata.size()) + abs(tutete[0]-tutete[1]));
		swap(totata, tutete);
	}

	if(res == INF) cout << -1 << endl;
	else {
		cout.setf(ios::fixed);
		cout.precision(13);
		cout << res << endl;
	}

}

int main()
{
	int M,N;
	cin >> M >> N;
	vector<P> totata(M), tutete(N);

	for(int i=0; i<M; i++) {
		double a,b;
		cin >> a >> b;
		totata[i] = P(a,b);
	}

	for(int i=0; i<N; i++) {
		double a,b;
		cin >> a >> b;
		tutete[i] = P(a,b);
	}

	solve(totata, tutete);
}