#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

typedef long double ld;

const int SZ = 110;
const ld eps = 1e-9;

struct point {
	int x, y;
};
point operator+(point a, point b) { return {a.x + b.x, a.y + b.y}; }
point operator-(point a, point b) { return {a.x - b.x, a.y - b.y}; }
int operator*(point a, point b) { return a.x * b.x + a.y * b.y; }
int operator/(point a, point b) { return a.x * b.y - a.y * b.x; }

int ccw(point p, point q, point r) {
	int s = (q - p) / (r - p);
	return (s > 0) - (s < 0);
}
pii cross(point p, point q, point r, point v) {
	if (v / (q - p) < 0 && v / (r - p) < 0) return {-1, 1};
	if (v / (q - p) > 0 && v / (r - p) > 0) return {-1, 2};
	point u = r - q;
	int a = (q - p) / u, b = v / u;
	if (b == 0 || 1ll * a * b < 0) return {-1, 3};
	if (a < 0) a *= -1, b *= -1;
	return {a, b};
}

struct pointd {
	ld x, y;
	pointd() : x(0), y(0) {}
	pointd(point p) : x(p.x), y(p.y) {}
	pointd(ld x, ld y) : x(x), y(y) {}
};
pointd operator+(pointd a, pointd b) { return {a.x + b.x, a.y + b.y}; }
pointd operator-(pointd a, pointd b) { return {a.x - b.x, a.y - b.y}; }
ld operator*(pointd a, pointd b) { return a.x * b.x + a.y * b.y; }
ld operator/(pointd a, pointd b) { return a.x * b.y - a.y * b.x; }
pointd operator*(ld k, pointd a) { return {k * a.x, k * a.y}; }

int ccw(pointd p, pointd q, pointd r) {
	ld s = (q - p) / (r - p);
	return (s > eps) - (s < -eps);
}
bool point_on_line(pointd p, pointd q, pointd r) {
	ld s = (q - p) * (r - p);
	return ccw(p, q, r) == 0 && -eps <= s && s <= (q - p) * (q - p);
}

pointd hypot(pointd p, pointd q, pointd r, bool &flag) {
	ld s = (q - p) * (r - p);
	if (s < -eps || s > (q - p) * (q - p) + eps) {
		flag = false; return r;
	}
	s /= (q - p) * (q - p);

	// cout << "hypot " << "(" << r.x << ", " << r.y << ") to segment (" << p.x << ", " << p.y << ") and (" << q.x << ", " << q.y << ")\n";
	// cout << "(" << (p + s * (q - p)).x << ", " << (p + s * (q - p)).y << ")\n";
	return p + s * (q - p);
}
bool cross(pointd p, pointd q, pointd r, pointd s) {
	if (ccw(p, q, r) == 0 && ccw(p, q, s) == 0) return false;
	if (point_on_line(p, q, r) || point_on_line(p, q, s) || point_on_line(r, s, p) || point_on_line(r, s, q)) return true;
	return ccw(p, q, r) * ccw(p, q, s) < 0 && ccw(r, s, p) * ccw(r, s, q) < 0;
}
ld intersect(pointd p, pointd u, pointd q, pointd v) {
	return ((q - p) / v) / (u / v);
}

int n; point P[SZ];
vector<pair<ld, int>> G[SZ];
ld ds[SZ];

bool polygon_in(pointd p) {
	bool flag = false;
	for (int i = 0; i < n; i++) {
		pointd q = P[i], r = P[(i + 1) % n];
		if (point_on_line(q, r, p)) return true;
	}
	for (int i = 0; i < n; i++) {
		pointd q = P[i], r = P[(i + 1) % n];
		if (q.y < r.y) swap(q, r);
		if (q.y > p.y + eps && r.y > p.y + eps) continue;
		if (q.y < p.y + eps && r.y < p.y + eps) continue;
		if (ccw(q, r, p) <= 0) {
			flag ^= 1;
		}
	}
	return flag;
}

int main() {
	cin.tie(0); ios_base::sync_with_stdio(0);
	cout.precision(10);

	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> P[i].x >> P[i].y;
	}
	cin >> P[n].x >> P[n].y;
	cin >> P[n + 1].x >> P[n + 1].y;

	point Q[n];
	for (int i = 0; i < n; i++) Q[i] = P[i];
	auto sgn = [&](point p) {
		return (p.y == 0) ? p.x > 0 : p.y > 0;
	};
	sort(Q, Q + n, [&](point p, point q) {
		if (sgn(p - P[n + 1]) != sgn(q - P[n + 1])) return sgn(p - P[n + 1]);
		else return ccw(P[n + 1], p, q) > 0;
	});

	pointd R[2 * n];
	for (int i = 0; i < n; i++) {
		point v = (Q[i] - P[n + 1]) + (Q[(i + 1) % n] - P[n + 1]);

		// cout << "between " << "(" << Q[i].x << ", " << Q[i].y << ") and (" << Q[(i + 1) % n].x << ", " << Q[(i + 1) % n].y << ")\n";

		pii M = {-1, 0}; int p = -1;
		for (int j = 0; j < n; j++) {
			point q = P[j], r = P[(j + 1) % n];
			pii K = cross(P[n + 1], q, r, v);
			if (K.ff != -1) {
				if (M.ff == -1 || 1ll * M.ff * K.ss > 1ll * M.ss * K.ff) M = K, p = j;
			}
		}
		assert(p != -1);

		pii A = cross(P[n + 1], P[p], P[(p + 1) % n], Q[i] - P[n + 1]);
		pii B = cross(P[n + 1], P[p], P[(p + 1) % n], Q[(i + 1) % n] - P[n + 1]);

		// cout << A.ff << "/" << A.ss << " " << B.ff << "/" << B.ss << '\n';

		R[2 * i] = (ld)A.ff / A.ss * (Q[i] - P[n + 1]) + P[n + 1];
		R[2 * i + 1] = (ld)B.ff / B.ss * (Q[(i + 1) % n] - P[n + 1]) + P[n + 1];
	
		// if (ccw(P[n + 1], R[2 * i], P[n]) && ccw(P[n + 1], P[n], R[2 * i + 1]) && ccw(R[2 * i], R[2 * i + 1], P[n]) >= 0) {
		// 	return !(cout << fixed << 0 << '\n');
		// }
	}
	// for (int i = 0; i < 2 * n; i++) {
	// 	cout << "(" << R[i].x << ", " << R[i].y << ")\n";
	// }

	vector<pair<pii, pointd>> V;
	for (int i = 0; i <= n; i++) for (int j = 0; j < i; j++) V.push_back({{i, j}, P[j]});
	for (int i = 0; i <= n; i++) for (int j = 0; j < 2 * n; j++) V.push_back({{i, n + 1}, R[j]});
	for (int i = 0; i <= n; i++) for (int j = 0; j < 2 * n; j++) {
		pointd q = R[j], r = R[(j + 1) % (2 * n)];
		if (abs((q - r) * (q - r)) < 1e-12) continue;

		bool flag = true;
		pointd h = hypot(q, r, P[i], flag);
		if (flag) V.push_back({{i, n + 1}, h});
	}

	for (auto [pr, s] : V) {
		auto [i, j] = pr;
		pointd p = P[i];

		vector<ld> A = {0, 1};
		for (int k = 0; k < n; k++) {
			pointd q = P[k], r = P[(k + 1) % n];
			bool f = cross(p, s, q, r);
			if (f) {
				A.push_back(intersect(p, s - p, q, r - q));
			}
		}
		sort(A.begin(), A.end());

		int sz = A.size();
		bool flag = true;
		for (int k = 0; k < sz - 1; k++) {
			ld K = 0.5 * (A[k + 1] + A[k]);
			pointd m = p + K * (s - p);
			if (!polygon_in(m)) {
				flag = false;
				break;
			}
		}
		if (flag) {
			ld d = sqrtl((s - p) * (s - p));
			// cout << "edge between " << i << " and " << j << " -> " << d << '\n';
			G[i].push_back({d, j});
			G[j].push_back({d, i});
		}
	}

	fill(ds, ds + SZ, 1e18);
	priority_queue<pair<ld, int>> pq;
	ds[n] = 0;
	pq.push({0, n});
	while (!pq.empty()) {
		auto [d, v] = pq.top(); pq.pop();
		if (ds[v] != -d) continue;
		for (auto [w, x] : G[v]) {
			if (ds[x] > ds[v] + w) {
				ds[x] = ds[v] + w;
				pq.push({-ds[x], x});
			}
		}
	}
	cout << fixed << ds[n + 1] << '\n';
}