#include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;

ld EPS=1e-11,DINF=1e9;
struct pt {
	ld x,y;
	pt(ld x, ld y):x(x),y(y){}
	pt(){}
	ld norm2(){return *this**this;}
	ld norm(){return sqrt(norm2());}
	bool operator==(pt p){return abs(x-p.x)<=EPS&&abs(y-p.y)<=EPS;}
	pt operator+(pt p){return pt(x+p.x,y+p.y);}
	pt operator-(pt p)const{return pt(x-p.x,y-p.y);}
	pt operator*(ld t){return pt(x*t,y*t);}
	pt operator/(ld t){return pt(x/t,y/t);}
	ld operator*(pt p){return x*p.x+y*p.y;}
	ld angle(pt p){return acos(*this*p/(norm()*p.norm()));}
	pt unit(){return *this/norm();}
	ld operator%(pt p){return x*p.y-y*p.x;}
	bool operator<(pt p)const{return x<p.x-EPS||(abs(x-p.x)<=EPS&&y<p.y-EPS);}
	bool left(pt p, pt q){return (q-p)%(*this-p)>EPS;}
	bool right(pt p, pt q){return (q-p)%(*this-p)<-EPS;}
	bool in(pt p, pt q){return abs((q-p)%(*this-p))<EPS;}
	pt rot(pt r){return pt(*this%r,*this*r);}
	pt rot(ld a){return rot(pt(sin(a),cos(a)));}
};
pt ccw90(1,0);
pt cw90(-1,0);
int sgn(ld x){return x<-EPS?-1:x>EPS;}

struct Cmp {
	pt r;
	Cmp(pt r):r(r){}
	int cuad(const pt &a)const {
		if(a.x>EPS&&a.y>=-EPS)return 0;
		if(a.x<=EPS&&a.y>EPS)return 1;
		if(a.x<-EPS&&a.y<=EPS)return 2;
		if(a.x>=-EPS&&a.y<-EPS)return 3;
		return -1;
	}
	bool cmp(const pt& p1, const pt& p2)const {
		int c1=cuad(p1),c2=cuad(p2);
		ld me=p1.y*p2.x;
		ld he=p1.x*p2.y;
		pt pp1=p1, pp2=p2;
		if(c1==c2)return me+EPS<he || (abs(me-he)<EPS && pp1.norm()+EPS<pp2.norm());
		return c1<c2;
	}
	bool operator()(const pt& p1, const pt& p2)const {
		return cmp(p1-r,p2-r);
	}
};

struct ln {
	pt p,pq;
	ln(pt p, pt q):p(p),pq(q-p){}
	ln(){}
	bool operator/(ln l){return abs(pq.unit()%l.pq.unit())<=EPS;} // 2D
	pt operator^(ln l){
		if(*this/l)return pt(DINF,DINF);
		pt r=l.p+l.pq*((p-l.p)%pq/(l.pq%pq));
		return r;
	}
	pt proj(pt r){return p+pq*((r-p)*pq/pq.norm2());}
};

bool seghas(pt a, pt b, pt c){
	ld me=(a-b).norm();
	ld he=(a-c).norm()+(b-c).norm();
	return abs(me-he)<EPS;
}

bool has(vector<pt> &p, pt q){
	int n=SZ(p);
	fore(i,0,n)if(seghas(p[i],p[(i+1)%n],q))return true;
	int cnt=0;
	fore(i,0,n){
		int j=(i+1)%n;
		int k=sgn((q-p[j])%(p[i]-p[j]));
		int u=sgn(p[i].y-q.y),v=sgn(p[j].y-q.y);
		if(k>0&&u<0&&v>=0)cnt++;
		if(k<0&&v<0&&u>=0)cnt--;
	}
	return cnt!=0;
}

ld getdist(pt p, pt dir, vector<pt> &v){
	if(!has(v, p+(dir*1e-5))) return 0;
	
	int n=SZ(v);
	ld lef=1e18,rig=1e18;
	pt asd=p+dir.rot(cw90);
	
	fore(i,0,n){
		pt a=v[i], b=v[(i+1)%n];
		
		if(abs(dir%(b-a)) < EPS){
			if(p.in(a,b)){
				if(a==p) rig=0;
				if(b==p) lef=0;
				if(a.left(p,asd) && b.left(p,asd)){
					if((a-p).norm() < (b-p).norm()) rig=min(rig, (a-p).norm());
					else lef=min(lef, (b-p).norm());
				}
			}		
			continue;
		}
		
		pt to=ln(a,b)^ln(p,p+dir);
		pt asd=p+dir.rot(cw90);
		if(!seghas(a,b,to) || to.right(p,asd)) continue;
		
		//interseco con el segmento
		ld ds=(to-p).norm();
		
		if(to==p)continue;
		
		if(to==a){
			if(b.right(p,p+dir)) rig=min(rig,ds);
			else lef=min(lef,ds);
		}
		
		else if(to==b){
			if(a.right(p,p+dir)) rig=min(rig,ds);
			else lef=min(lef,ds);
		}
		
		else{
			lef=min(lef,ds);
			rig=min(rig,ds);
		}
	}
	
	
	ld ans=max(lef,rig);
	return ans;
}

vector<pt> getbox(pt p, vector<pt> &v){
	auto vv=v;
	sort(ALL(vv),Cmp(p));
	
	vector<pt> ans;

	fore(i,0,SZ(vv)){
		if(i && vv[i].in(vv[i-1],p))continue;
		
		pt q=vv[i];
		pt dir=(q-p).unit();
		
		ld now=getdist(p, dir, v);
		pt me=p+(dir*now);
		
		ld he=(vv[i]-p).norm();
		if(he<=now+EPS){
			int pos=-1,n=SZ(v);
			fore(j,0,n) if(v[j]==vv[i]) pos=(j-1+n)%n;
			if(!v[pos].left(p,vv[i])) swap(me,q);
			ans.pb(me);
			ans.pb(q);
		}
		else{
			ans.pb(me);
		}
	}
	
	ans.erase(unique(ALL(ans)),ans.end());
	
	return ans;
}

pt getdir(pt a, pt b, pt c){
	pt pr=ln(a,b).proj(c);
	if(seghas(a,b,pr)) return pr;
	else if((a-c).norm() < (b-c).norm()) return a;
	return b;
}

const int MAXN=110;
vector<pair<int,ld>> g[MAXN];
ld bst[MAXN];

int main(){FIN;
	int n; cin>>n;
	vector<pt> v(n);
	fore(i,0,n) cin>>v[i].x>>v[i].y;
	pt me,he; cin>>me.x>>me.y>>he.x>>he.y;
	
	//entre vertices del poligono
	fore(i,0,n) fore(j,0,n) if(i!=j){
		ld mx=getdist(v[i], (v[j]-v[i]).unit(), v);
		ld he=(v[j]-v[i]).norm();
		if(he<=mx+EPS){
			g[i].pb({j,he});
		}
	}
	
	//desde me hasta i
	fore(i,0,n){
		ld mx=getdist(me, (v[i]-me).unit(), v);
		ld he=(me-v[i]).norm();
		if(he<=mx+EPS){
			g[n].pb({i,he});
		}
	}
	
	vector<pt> box=getbox(he,v);
	
	auto vv=v;
	vv.pb(me);
	fore(i,0,n+1){
		bst[i]=1e18;
		
		if(has(box,vv[i])){
			bst[i]=0;
			continue;
		}
		
		fore(j,0,SZ(box)){
			pt p=box[j],q=box[(j+1)%SZ(box)];
			pt to=getdir(p,q,vv[i]);
			ld mx=getdist(vv[i], (to-vv[i]).unit(), v);
			ld he=(to-vv[i]).norm();
			if(he<=mx+EPS) bst[i]=min(bst[i],he);
		}
	}
	
	
	
	fore(i,0,n+1) g[i].pb({n+1,bst[i]});
	
	priority_queue<pair<ld,int>, vector<pair<ld,int>>, greater<pair<ld,int>>> q;
	vector<ld> ans(n+2,1e18);
	q.push({0,n});
	ans[n]=0;
	
	while(SZ(q)){
		ld d=q.top().fst; int pos=q.top().snd; q.pop();
		if(abs(ans[pos]-d)>EPS) continue;
		for(auto x:g[pos]){
			ld nd=d+x.snd;
			if(nd+EPS<ans[x.fst]){
				ans[x.fst]=nd;
				q.push({nd,x.fst});
			}
		}
	}
	
	ld res=1e18;
	
	cout<<fixed<<setprecision(10)<<ans[n+1]<<"\n";
}