import math

N = int(input())

points = [[int(coord) for coord in input().split()] for _ in range(N)]

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

    def __repr__(self):
        return f"[{self.x}, {self.y} - {self.destroyed}]"


points = [Point(x,y, False) for x, y in points]
byX = sorted(points, key=lambda point: point.x)
byY = sorted(points, key=lambda point: point.y)

startX = 0
endX = N-1

startY = 0
endY = N-1

for _ in range(N//4 - 1):
    toRemove = []
    for point in byX[startX:]:
        startX += 1
        if point.destroyed:
            continue
        toRemove.append(point)
        break

    while byX[startX].destroyed:
        startX += 1

    if byX[startX-1].x == byX[startX].x:
        toRemove.append(byX[startX])
        startX += 1


    for point in byY[startY:]:
        startY += 1
        if point.destroyed:
            continue
        toRemove.append(point)
        break

    while byY[startY].destroyed:
        startY += 1

    if byY[startY-1].y == byY[startY].y:
        toRemove.append(byY[startY])
        startY += 1



    for point in reversed(byY[:endY+1]):
        endY -= 1
        if point.destroyed:
            continue
        toRemove.append(point)
        break

    while byY[endY].destroyed:
        endY -= 1

    if byY[endY+1].y == byY[endY].y:
        toRemove.append(byY[endY])
        endY -= 1

    for point in reversed(byX[:endX+1]):
        endX -= 1
        if point.destroyed:
            continue
        toRemove.append(point)
        break

    while byX[endX].destroyed:
        endX -= 1

    if byX[endX+1].x == byX[endX].x:
        toRemove.append(byX[endX])
        endX -= 1

    for point in toRemove:
        point.destroyed = True

final = [point for point in points if not point.destroyed]
assert len(final) == 4

AB = (final[1].x - final[0].x, final[1].y - final[0].y)
AC = (final[2].x - final[0].x, final[2].y - final[0].y)

print(abs(AB[0] * AC[1] - AB[1] * AC[0]))