class point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __add__(p, q): return point(p.x+q.x, p.y+q.y)
    def __sub__(p, q): return point(p.x-q.x, p.y-q.y)
    def __mul__(p, c): return point(c*p.x, c*p.y)
    def dot(p, q): return p.x*q.x + p.y*q.y
    def cross(p, q): return p.x*q.y - p.y*q.x
    def quadrant(self):
        if self.y > 0 and self.x >= 0: return 0
        if self.x < 0 and self.y >= 0: return 1
        if self.y < 0 and self.x <= 0: return 2
        return 3
    def __lt__(p, q):
        a = p.quadrant()
        b = q.quadrant()
        if a != b: return a < b
        return p.cross(q) > 0
    def __str__(self): return '(%s,%s)' % (self.x, self.y)
    
class ray:
    def __init__(self, P=None, dP=None):
        self.P = P if P else point()
        self.dP = dP if dP else point()
    def isect(L1, L2):
        det = L1.dP.cross(L2.dP)
        if abs(det) < 1e-9: return None
        s = 1.0*L2.dP.cross(L1.P-L2.P)/det
        return L1.P + L1.dP*s
    def __lt__(L1, L2): return L1.dP < L2.dP
    def __str__(self): return '%s dir %s' % (self.P, self.dP)
    
def area(P):
    return sum(P[i-1].P.cross(P[i].P) for i in range(len(P))) / 2


n = int(raw_input())
segs = [ray() for _ in range(n)]
for i in range(n):
    (segs[i].P.x, segs[i].P.y) = map(float, raw_input().split())
for i in range(n):
    segs[i].dP = segs[i-1].P - segs[i].P
    
segs.sort()

d = 0
for i in range(1, n):
    if segs[d] < segs[i]:
        d += 1
        segs[d] = segs[i]
    elif segs[i].dP.cross(segs[i].P - segs[d].P) > 0:
        segs[d] = segs[i]

segs[d+1:] = []
segs.append(segs[0])


def solve():
    n = len(segs)
    P = [segs[0]]

    def add_line(L):
        q = L.isect(P[-1])
        if q is None: return False
        while len(P) > 1 and P[-1].dP.dot(q-P[-1].P) <= 0:
            P.pop()
            q = L.isect(P[-1])
            if q is None: return False
        P.append(ray(q, L.dP))
        return True

    for i in range(1, n):
        if not add_line(segs[i]): return 0
    a = 0
    while a+1 < len(P)-1 and P[a].dP.dot(P[-1].P-P[a+1].P) > 0:
        a += 1
        P.pop()
        if not add_line(P[a]): return 0
    P = P[a+1:]
    return area(P)

print '%.9f' % solve()