import math
from queue import PriorityQueue

EPS = 1e-11
DINF = 1e9


class pt:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, p):
        return abs(self.x - p.x) <= EPS and abs(self.y - p.y) <= EPS

    def __add__(self, p):
        return pt(self.x + p.x, self.y + p.y)

    def __sub__(self, p):
        return pt(self.x - p.x, self.y - p.y)

    def __mul__(self, t):
        return pt(self.x * t, self.y * t)

    def __truediv__(self, t):
        return pt(self.x / t, self.y / t)

    def __matmul__(self, p):
        return self.x * p.x + self.y * p.y

    def norm2(self):
        return self @ self

    def norm(self):
        return math.sqrt(float(self.norm2()))

    def unit(self):
        return self / self.norm()

    def __mod__(self, p):
        return self.x * p.y - self.y * p.x

    def __lt__(self, p):
        return self.x < p.x - EPS or (abs(self.x - p.x) <= EPS and self.y < p.y - EPS)

    def left(self, p, q):
        return (q - p) % (self - p) > EPS

    def right(self, p, q):
        return (q - p) % (self - p) < -EPS

    def in_seg(self, p, q):
        return abs((q - p) % (self - p)) < EPS

    def rot(self, r):
        return pt(self % r, self * r)


def ccw90():
    return pt(1, 0)


def cw90():
    return pt(-1, 0)


def sgn(x):
    return -1 if x < -EPS else 1 if x > EPS else 0


class Cmp:
    def __init__(self, r):
        self.r = r

    def cuad(self, a):
        if a.x > EPS and a.y >= -EPS:
            return 0
        if a.x <= EPS and a.y > EPS:
            return 1
        if a.x < -EPS and a.y <= EPS:
            return 2
        if a.x >= -EPS and a.y < -EPS:
            return 3
        return -1

    def cmp(self, p1, p2):
        c1 = self.cuad(p1)
        c2 = self.cuad(p2)
        me = p1.y * p2.x
        he = p1.x * p2.y
        pp1 = p1
        pp2 = p2
        if c1 == c2:
            return me + EPS < he or (abs(me - he) < EPS and pp1.norm() + EPS < pp2.norm())
        return c1 < c2

    def __call__(self, p1, p2):
        return self.cmp(p1 - self.r, p2 - self.r)


class ln:
    def __init__(self, p, q):
        self.p = p
        self.pq = q - p

    def __truediv__(self, l):
        return abs(self.pq.unit() % l.pq.unit()) <= EPS

    def __xor__(self, l):
        if self / l:
            return pt(DINF, DINF)
        r = l.p + l.pq * ((self.p - l.p) % self.pq / (l.pq % self.pq))
        return r

    def proj(self, r):
        return self.p + self.pq * ((r - self.p) @ self.pq / self.pq.norm2())


def seghas(a, b, c):
    me = (a - b).norm()
    he = (a - c).norm() + (b - c).norm()
    return abs(me - he) < EPS


def has(p, q):
    n = len(p)
    for i in range(n):
        if seghas(p[i], p[(i + 1) % n], q):
            return True
    cnt = 0
    for i in range(n):
        j = (i + 1) % n
        k = sgn((q - p[j]) % (p[i] - p[j]))
        u = sgn(p[i].y - q.y)
        v = sgn(p[j].y - q.y)
        if k > 0 and u < 0 and v >= 0:
            cnt += 1
        if k < 0 and v < 0 and u >= 0:
            cnt -= 1
    return cnt != 0


def between(a, b, c):
    o = pt(0, 0)
    if b.left(o, a):
        return not c.left(o, a) or not c.right(o, b)
    else:
        return not c.right(o, b) and not c.left(o, a)


def getdist(p, dir, v):
    n = len(v)
    for i in range(n):
        if v[i] == p:
            pre = v[(i - 1 + n) % n]
            nex = v[(i + 1) % n]
            if not between(pre - p, nex - p, dir):
                return 0

    lef = 1e18
    rig = 1e18
    asd = p + dir.rot(cw90())

    for i in range(n):
        a = v[i]
        b = v[(i + 1) % n]

        if abs(dir % (b - a)) < EPS:
            if p.in_seg(a, b):
                if a == p:
                    rig = 0
                if b == p:
                    lef = 0
                if a.left(p, asd) and b.left(p, asd):
                    if (a - p).norm() < (b - p).norm():
                        rig = min(rig, (a - p).norm())
                    else:
                        lef = min(lef, (b - p).norm())
        else:
            to = ln(a, b) ^ ln(p, p + dir)
            asd = p + dir.rot(cw90())
            if not seghas(a, b, to) or to.right(p, asd):
                continue

            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)
            elif 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)

    ans = max(lef, rig)
    return ans


def getbox(p, v):
    vv = sorted(v, key=Cmp(p))

    ans = []
    for i in range(len(vv)):
        if i and vv[i].in_seg(vv[i - 1], p):
            continue

        q = vv[i]
        dir = (q - p).unit()

        now = getdist(p, dir, v)
        me = p + (dir * now)

        he = (vv[i] - p).norm()
        if he <= now + EPS:
            pos = -1
            n = len(v)
            for j in range(n):
                if v[j] == vv[i]:
                    pos = (j - 1 + n) % n
            if not v[pos].left(p, vv[i]):
                me, q = q, me
            ans.append(me)
            ans.append(q)
        else:
            ans.append(me)

    ans = list(set(ans))
    return ans


def getdir(a, b, c):
    pr = ln(a, b).proj(c)
    if seghas(a, b, pr):
        return pr
    elif (a - c).norm() < (b - c).norm():
        return a
    return b


MAXN = 110
g = [[] for _ in range(MAXN)]
bst = [1e18] * MAXN

n = int(input())
v = [pt(0, 0) for _ in range(n + 2)]
for i in range(n + 2):
    x, y = map(int, input().split())
    v[i] = pt(x, y)

me = v[n]
he = v[n + 1]
v = v[:-2]

for i in range(n):
    for j in range(n):
        if i != j:
            mx = getdist(v[i], (v[j] - v[i]).unit(), v)
            he = (v[j] - v[i]).norm()
            if he <= mx + EPS:
                g[i].append((j, he))

for i in range(n):
    mx = getdist(me, (v[i] - me).unit(), v)
    he = (me - v[i]).norm()
    if he <= mx + EPS:
        g[n].append((i, he))

box = getbox(he, v)
vv = v + [me]

for i in range(n + 1):
    bst[i] = 1e18

    if has(box, vv[i]):
        bst[i] = 0
        continue

    for j in range(len(box)):
        p = box[j]
        q = box[(j + 1) % len(box)]
        to = getdir(p, q, vv[i])
        mx = getdist(vv[i], (to - vv[i]).unit(), v)
        he = (to - vv[i]).norm()
        if he <= mx + EPS:
            bst[i] = min(bst[i], he)

for i in range(n + 1):
    g[i].append((n + 1, bst[i]))

q = PriorityQueue()
ans = [1e18] * (n + 2)
q.put((0, n))
ans[n] = 0

while not q.empty():
    d, pos = q.get()
    if abs(ans[pos] - d) > EPS:
        continue
    for x in g[pos]:
        nd = d + x[1]
        if nd + EPS < ans[x[0]]:
            ans[x[0]] = nd
            q.put((nd, x[0]))

res = 1e18
print("{:.10f}".format(float(ans[n + 1])))