#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
#define int long long
//typedef long long int lint;

struct tacka{
    int x;
    int y;
    bool operator<(const tacka& B) const {
        if(x < B.x){
            return true;
        }
        else if(x > B.x){
            return false;
        }
        else{
            if(y < B.y){
                return true;
            }
            else{
                return false;
            }
        }
    }
};



long double rast(tacka A, tacka B){
    long double x = sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
    return x;
}

int povrs(tacka A, tacka B, tacka C){
    int P = (A.x * (B.y - C.y) + B.x * (C.y - A.y) + C.x * (A.y - B.y)) / 2;
    return P;
}

bool klok(tacka A, tacka B, tacka C){
    //skalarni proizvod vektora, sigma stanic!
    if(((B.x - A.x) * (C.y - A.y) - (B.y - A.y) * (C.x - A.x) < 0)){
        return true;
    }
    else{
        return false;
    }
}

tacka reftacka;

bool sortiraj(const tacka& A, const tacka& B){
    double ugaoA, ugaoB;
    if(A.x == reftacka.x){
        ugaoA = 3.1415926 / 2;
    }
    else{
        ugaoA = atan(((double)A.y - (double)reftacka.y) / ((double)A.x - (double)reftacka.x));        
    }
    if(B.x == reftacka.x){
        ugaoB = 3.1415926 / 2; 
    }
    else{
        ugaoB = atan(((double)B.y - (double)reftacka.y) / ((double)B.x - (double)reftacka.x)); 
    }
    if(ugaoA < 0){
        ugaoA = 3.1415926 + ugaoA;
    }
    if(ugaoB < 0){
        ugaoB = 3.1415926 + ugaoB;
    }
    if(ugaoA > ugaoB){
        return false;
    }
    else{
        return true;
    }
}

tacka drugatacka(stack<tacka>& stek){
    tacka x0 = stek.top();
    stek.pop();
    tacka x1 = stek.top();
    stek.push(x0);
    return x1;
}

int algo(vector<tacka> C){
    vector<tacka> A(C.size());
    for(int i = 0; i < C.size(); i++){
        A[i] = C[i];
    }
    tacka A0;
    int n = A.size();
    for(int i = 0; i < n; i++){
        tacka t;
        t.x = A[i].x;
        t.y = A[i].y;
        if(i == 0){
            A0.x = t.x;
            A0.y = t.y;
        }
        else{
            if(t.y < A0.y){
                A0.x = t.x;
                A0.y = t.y;
            }
            else if(t.y == A0.y){
                if(t.x < A0.x){
                    A0.x = t.x;
                    A0.y = t.y;
                }
            }
        }
    } 
    for(int i = 0; i < n; i++){
        if((A[i].x == A0.x) && (A[i].y == A0.y)){
            swap(A[i], A[0]);
        }
    }
    reftacka = A[0];
    vector<tacka> B(n - 1);
    for(int i = 1; i < n; i++){
        B[i - 1] = A[i];
    }
    sort(B.begin(), B.end(), sortiraj);
    for(int i = 1; i < n; i++){
        A[i] = B[i - 1];
    }
    stack<tacka> poligon;
    poligon.push(A[0]);
    poligon.push(A[1]);
        for(int i = 2; i < n; i++){
        while(klok(drugatacka(poligon), poligon.top(), A[i])){
            poligon.pop();
        }
        poligon.push(A[i]);
    }
    vector<tacka> mnog;
    while(!poligon.empty()){
        mnog.push_back(poligon.top());
        poligon.pop();
    }
    reverse(mnog.begin(), mnog.end());
    /* mrzim trigonometriju 
    map<tacka, bool> mapa;
    while(true){
        if((A[0].x == A[A.size() - 1].x) && (A[0].y == A[A.size() - 1].y)){
            if(A.size() != 1){
                A.erase(A.end());
                break;
            }
        }
        tacka A0 = A[A.size() - 1];
        tacka t;
        double minkoef = 360;
        for(tacka tx : skup){
            if(mapa[tx]){
                continue;
            }
            if((tx.x != A0.x) || (tx.y != A0.y)){
                double koef;
                if(tx.x == A0.x){
                    koef = numeric_limits<double>::min();
                }
                else{
                    koef = atan(((double)tx.y - (double)A0.y) / ((double)tx.x - (double)A0.x));
                    if(koef < 0){
                        koef += 3.141526;
                    }
                }
                if(koef <= minkoef){
                    t.x = tx.x;
                    t.y = tx.y;
                    minkoef = koef;
                }
            }
        }
        A.push_back(t);
        mapa[t] = true;
    }
    //sada imam poliedar :)
    for(int i = 0; i < A.size(); i++){
        cout << A[i].x << " " << A[i].y << endl;
    }
    */

    int P = 0;
    for(int i = 1; i < (mnog.size() - 1); i++){
        P += povrs(mnog[0], mnog[i], mnog[i + 1]);
    }
    return P;
}

vector<tacka> algo2(vector<tacka> C){
    vector<tacka> A(C.size());
    for(int i = 0; i < C.size(); i++){
        A[i] = C[i];
    }
    tacka A0;
    int n = A.size();
    for(int i = 0; i < n; i++){
        tacka t;
        t.x = A[i].x;
        t.y = A[i].y;
        if(i == 0){
            A0.x = t.x;
            A0.y = t.y;
        }
        else{
            if(t.y < A0.y){
                A0.x = t.x;
                A0.y = t.y;
            }
            else if(t.y == A0.y){
                if(t.x < A0.x){
                    A0.x = t.x;
                    A0.y = t.y;
                }
            }
        }
    } 
    for(int i = 0; i < n; i++){
        if((A[i].x == A0.x) && (A[i].y == A0.y)){
            swap(A[i], A[0]);
        }
    }
    reftacka = A[0];
    vector<tacka> B(n - 1);
    for(int i = 1; i < n; i++){
        B[i - 1] = A[i];
    }
    sort(B.begin(), B.end(), sortiraj);
    for(int i = 1; i < n; i++){
        A[i] = B[i - 1];
    }
    stack<tacka> poligon;
    poligon.push(A[0]);
    poligon.push(A[1]);
        for(int i = 2; i < n; i++){
        while(klok(drugatacka(poligon), poligon.top(), A[i])){
            poligon.pop();
        }
        poligon.push(A[i]);
    }
    vector<tacka> mnog;
    while(!poligon.empty()){
        mnog.push_back(poligon.top());
        poligon.pop();
    }
    reverse(mnog.begin(), mnog.end());
    return mnog;    
}

void solve(){
    int n;
    cin >> n;
    vector<tacka> A(n);
    for(int i = 0; i < n; i++){
        cin >> A[i].x >> A[i].y;
    }
    vector<tacka> mnog = algo2(A);
    int minP = numeric_limits<int>::max();
    for(int i = 0; i < mnog.size(); i++){
        vector<tacka> B;
        for(int j = 0; j < n; j++){
            if((A[j].x != mnog[i].x) || (A[j].y != mnog[i].y)){
                B.push_back(A[j]);
            }
        }
        minP = min(minP, algo(B));
    }
    cout << minP << endl;
}   
 


signed main(){
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int t = 1;
    //cin >> t;
    while(t--){
        solve();
    }
    return 0;
}