#include <stdio.h>
#include <math.h>
#include <algorithm>

using namespace std;

#define MAX_N 100010

#define inf 100000000000000.0
#define VMAX 1000000

int n, m;

double sol = inf;

struct punct {
    double x, y;
} A[MAX_N], Hull[MAX_N];

inline bool cmp(const punct &P, const punct &Q) {
    return atan2(P.y - A[1].y, P.x - A[1].x) < atan2(Q.y - A[1].y, Q.x - A[1].x);
}

inline double det(const punct &A, const punct &B, const punct &C) {
    return 1LL * A.x * B.y + 1LL * B.x * C.y + 1LL * C.x * A.y -
           1LL * A.x * C.y - 1LL * B.x * A.y - 1LL * C.x * B.y;
}

void get_hull() {
    int p = 1;

    for (int i = 2; i <= n; i++)
        if (A[i].x < A[p].x || (A[i].x == A[p].x && A[i].y < A[p].y))
            p = i;

    swap(A[1], A[p]);

    sort(A + 2, A + n + 1, cmp);

    Hull[1] = A[1]; Hull[2] = A[2]; m = 2;
    for (int i = 3; i <= n; i++) {
        //verific daca punctul curent este pe ultima latura a infasuratorii
        if (!(det(A[i], Hull[m], Hull[m - 1]) == 0 && min(Hull[m].x, Hull[m - 1].x) <= A[i].x && A[i].x <= max(Hull[m].x, Hull[m - 1].x)))
            Hull[++m] = A[i];

        while (m > 2 && det(Hull[m - 2], Hull[m - 1], Hull[m]) <= 0) {
            swap(Hull[m - 1], Hull[m]);
            m--;
        }
    }

    n = m;
    for (int i = 1; i <= n; i++)
        A[i] = Hull[i];
}

inline double dist(punct A, punct B) {
    double ans = (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);

    return sqrt(ans);
}

inline double dist_line(punct A, punct B, double m) { //dreapta fata de care trebuie sa gasesc distanta are tangenta m si trece prin B
    //cazuri speciale: m = 0 sau m = inf

    if (m == 0)
        return fabs(A.y - B.y);

    if (m == inf)
        return fabs(A.x - B.x);

    double n = B.y - m * B.x;

    punct C;
    C.x = B.x + 1;
    C.y = C.x * m + n;

    double h = det(A, B, C) / dist(B, C);
    if (h < 0)
        h = -h;

    return h;
}

inline int next(int i) {
    return (i < n) ? (i + 1) : 1;
}

inline double inv(double m) {
    if (m == 0)
        return inf;
    if (m == inf)
        return 0;

    return -1.0 / m;
}

void solve() {
    get_hull();

    //algoritm O(n^2)

    for (int i = 1; i <= n; i++) {
        int nxt = next(i);

        double m;
        if (A[i].x == A[nxt].x)
            m = inf;
        else
            m = 1.0 * (A[nxt].y - A[i].y) / (A[nxt].x - A[i].x);

        int left = i, up = i, right = i;

        //gasesc up si left
        for (int j = next(i); j != i; j = next(j)) {
            if (dist_line(A[j], A[i], m) > dist_line(A[up], A[i], m))
                up = j;
            if (dist_line(A[j], A[i], inv(m)) > dist_line(A[left], A[i], inv(m)))
                left = j;
        }

        for (int j = next(left); j != left; j = next(j))
            if (dist_line(A[j], A[left], inv(m)) > dist_line(A[right], A[left], inv(m)))
                right = j;

        double current_sol = dist_line(A[up], A[i], m) * dist_line(A[left], A[right], inv(m));
        if (current_sol < sol)
            sol = current_sol;
    }

    printf("%.2lf\n", sol);
}

int main() {

    freopen("rubarba.in", "r", stdin);
    freopen("rubarba.out", "w", stdout);

    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%lf %lf", &A[i].x, &A[i].y);

    solve();

    return 0;
}