#include<bits/stdc++.h>
using namespace std;
typedef long double ld; 
const ld eps=1E-15;
const ld pi=acos(-1);
const ld INF=1E15;
const int maxn=1E6+5; 
int q,n,m,top;
ld ans,f[maxn];
bool vis[maxn];
int size,head[maxn];
struct pt
{
	ld x,y;
	pt(ld a=0,ld b=0)
	{
		x=a,y=b;
	}
	void operator=(pt A)
	{
		x=A.x,y=A.y;
	}
	ld operator*(pt A)
	{
		return x*A.y-y*A.x;
	}
	pt operator-(pt A)
	{
		return pt(x-A.x,y-A.y);
	}
}target[maxn],barrier[maxn];
struct inf
{
	int id,x;
	inf(int a=0,int b=0)
	{
		id=a,x=b;
	}
}S[maxn];
struct edge
{
	int to,next;
	ld w;
}E[maxn];
//////////////////////////////////////////////////////////////////
//polygon
//////////////////////////////////////////////////////////////////
bool cmp(pt A,pt B)
{
	return A.x<B.x;
}
pt rotate(pt A,ld ra)
{
	return pt(A.x*cos(ra)-A.y*sin(ra),A.x*sin(ra)+A.y*cos(ra));
}
int face(pt A,pt B,pt C)
{
	ld y=(B.y-A.y)/(B.x-A.x)*(C.x-A.x);
	if(A.y+y>=C.y)
		return 1;
	return -1;
}
bool inside(pt A,pt B,pt C)
{
	return min(A.x,B.x)<=C.x&&C.x<=max(A.x,B.x);
}
ld dis(pt A,pt B)
{
	return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));
}
int cross(pt A,pt B)
{
	ld d=A*B;
	if(d>=eps)
		return 1;
	else
		return -1;
}
void push(inf A)
{
	if(A.id==S[top].id&&A.x==S[top].x)
		--top;
	else
		S[++top]=A;
}
//////////////////////////////////////////////////////////////////
//polygon
//////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////
//graph
//////////////////////////////////////////////////////////////////
void add(int u,int v,ld w)
{
	E[++size].to=v;
	E[size].next=head[u];
	E[size].w=w;
	head[u]=size;
}
void clear()
{
	for(int i=0;i<=top+1;++i)
		head[i]=0;
	head[maxn-5]=0;
	size=0;
}
ld spfa()
{
	for(int i=0;i<=top;++i)
		f[i]=INF;
	f[0]=0;
	vis[0]=1;
	queue<int>Q;
	Q.push(0);
	while(!Q.empty())
	{
		int u=Q.front();
		vis[u]=0;
		Q.pop();
		for(int i=head[u];i;i=E[i].next)
		{
			int v=E[i].to;
			ld nw=E[i].w+f[u];
			if(nw<f[v])
			{
				f[v]=nw;
				if(!vis[v])
				{
					vis[v]=1;
					Q.push(v);
				}
			}
		}
	}
	return f[top--];
}
bool check(int l,int r)
{
	for(int i=l+1;i<=r-1;++i)
		if(face(barrier[S[l].id],barrier[S[r].id],barrier[S[i].id])!=S[i].x)
			return false;
	return true;
} 
ld get(int x)
{
	clear();
	barrier[maxn-5]=target[x];
	push(inf(maxn-5,0));
	for(int i=1;i<=top;++i)
		for(int j=i+1;j<=top;++j)
			if(check(i,j))
				add(i,j,dis(barrier[S[i].id],barrier[S[j].id]));
	barrier[0]=target[1];
	for(int i=1;i<=top;++i)
		if(check(0,i))
			add(0,i,dis(barrier[0],barrier[S[i].id]));
	return spfa();
}

//////////////////////////////////////////////////////////////////
//graph
//////////////////////////////////////////////////////////////////

void solve()
{
	top=ans=0;
	cin>>n>>m;
	if(n==0&&m==0)
		exit(0);
	for(int i=1;i<=n;++i)
	{
		cin>>target[i].x>>target[i].y;
		target[i]=rotate(target[i],pi/3);
	}
	for(int i=1;i<=m;++i)
	{
		cin>>barrier[i].x>>barrier[i].y;
		barrier[i]=rotate(barrier[i],pi/3);
	}
	sort(barrier+1,barrier+m+1,cmp);
	pt now=target[1];
	for(int i=2;i<=n;++i)
	{
		if(target[i].x>now.x)
		{
			for(int j=1;j<=m;++j)
				if(inside(now,target[i],barrier[j]))
					push(inf(j,face(now,target[i],barrier[j])));
		}
		else
		{
			for(int j=m;j>=1;--j)
				if(inside(now,target[i],barrier[j]))
					push(inf(j,face(now,target[i],barrier[j])));
		}
		now=target[i];
	}
	cout<<fixed<<setprecision(4)<<get(n)<<endl;
}
int main()
{
	ios::sync_with_stdio(false);
	while(true)
		solve();
	return 0;
}



Measured memory_bytes: 74300