#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#include<bits/stdc++.h>
#include<atcoder/convolution>

using namespace std;
using namespace atcoder;
using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
ll MOD = 998244353;
ll MAX = 1e18;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll N;
    cin >> N;
    vector<ll> X(N),Y(N);
    for(ll i = 0;i < N;i++){
        cin >> X[i] >> Y[i];
    }
    ll ans = 0;
    for(ll ii = 0;ii < N;ii++){
        for(ll jj = ii + 1;jj < N;jj++){
            ll i = ii,j = jj;
            ll dx = X[i] - X[j];
            ll dy = Y[i] - Y[j];
            if(dy < 0){
                i = jj;
                j = ii;
                dx = X[i] - X[j];
                dy = Y[i] - Y[j];
            }
            vector<ll> A,B;
            if(dy == 0){
                for(ll k = 0;k < N;k++){
                    if(k == i || k == j) continue;
                    ll a = abs(X[j] - X[i]);
                    ll c = a * abs(Y[k] - Y[i]);
                    if(Y[k] > Y[i]){
                        A.push_back(c);
                    }
                    else{
                        B.push_back(c);
                    }
                }
            }
            else{
                for(ll k = 0;k < N;k++){
                    if(k == i || k == j) continue;
                    ll a1 = X[k] - X[i],b1 = Y[k] - Y[i],a2 = X[j] - X[i],b2 = Y[j] - Y[i];
                    ll c = a1 * b2 - b1 * a2;
                    if(c < 0) c = -c;
                    if((dy) * (X[k] - X[i]) + Y[i] * dx < Y[k] * dx){
                        A.push_back(c);
                    }
                    else{
                        B.push_back(c);
                    }
                }
            }
            sort(A.begin(),A.end());
            sort(B.begin(),B.end());
            if(!A.empty()) ans = max(ans,A.back() - A.front());
            if(!B.empty())ans = max(ans,B.back() - B.front());
            if(!A.empty() && !B.empty()) ans = max(ans,B.back() + A.back());
        }
    }
    cout << ans << endl;
}