#include<bits/stdc++.h>

struct Tacka {
    long long x;
    long long y;
};


bool uporedjivanje(Tacka& a, Tacka& b)
{
    if (a.y == b.y) {
        return a.x < b.x;
    } else {
        return a.y < b.y;
    }
}


int okret( Tacka& prva,  Tacka& druga,  Tacka& treca)
{
    long long a = (druga.y - prva.y) * (treca.x - druga.x) - (druga.x - prva.x) * (treca.y - druga.y);
    if (a == 0) {
        return 0;
    }
        if (a > 0) {
            return 1;
        }
            return 2;

    }



std::vector<Tacka> konveksnaGomila(std::vector<Tacka>& tacke) {
    int n = tacke.size();
    if (n < 3) return {};


    std::sort(tacke.begin(), tacke.end(), uporedjivanje);
    Tacka& prva = tacke[0];

    std::sort(tacke.begin() + 1, tacke.end(), [&](Tacka a, Tacka b) {
    int okretanje = okret(prva, a, b);
    if (okretanje == 0) {
        double Razdaljina1 = std::pow(prva.x - a.x, 2) + std::pow(prva.y - a.y, 2);
        double Razdaljina2 = std::pow(prva.x - b.x, 2) + std::pow(prva.y - b.y, 2);
        return Razdaljina1 < Razdaljina2;
    }
    return (okretanje == 2);
});


    std::vector<Tacka> sveTackice;
    sveTackice.push_back(tacke[0]);
    sveTackice.push_back(tacke[1]);
    sveTackice.push_back(tacke[2]);

    for (int i = 3; i < n; i++)
        {
        while (sveTackice.size() >= 2 &&
               okret(sveTackice[sveTackice.size() - 2], sveTackice[sveTackice.size() - 1], tacke[i]) != 2)
            {
            sveTackice.pop_back();
        }
        sveTackice.push_back(tacke[i]);
    }

    return sveTackice;
}


long long povrsina(const std::vector<Tacka>& oblik)
{
    long long povrs = 0;
    int n = oblik.size();




    for (int i = 0; i < n; i++)
        {
        int j = (i + 1) % n;
        povrs += oblik[i].x * oblik[j].y;
        povrs -= oblik[j].x * oblik[i].y;
    }

    return std::abs(povrs / 2);
}

int main() {
    int N;
    std::cin >> N;
    if (N<2) return 0;

    std::vector<Tacka> tacke(N);
    for (int i = 0; i < N; i++)
        {
        std::cin >> tacke[i].x >> tacke[i].y;
    }

    long long minimalnaPovrsina = LLONG_MAX;


    for (int i = 0; i < N; i++)
        {
        std::vector<Tacka> manjeTacaka = tacke;
        manjeTacaka.erase(manjeTacaka.begin() + i);

        std::vector<Tacka> gomila = konveksnaGomila(manjeTacaka);
        long long povrs = povrsina(gomila);
        minimalnaPovrsina = std::min(minimalnaPovrsina, povrs);
    }
    //geometrija :(
    std::cout << minimalnaPovrsina << std::endl;

    return 0;
}