#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


enum Type{
	RIGHT,
	LEFT,
};

struct Point{
	Point(long double arg_x,long double arg_y){
		x = arg_x;
		y = arg_y;
	}

	Point(){
		x = y = 0.0;
	}

	Point operator + (Point p){ return Point(x+p.x,y+p.y); }
	Point operator - (Point p){ return Point(x-p.x,y-p.y);}
	Point operator * (long double a){ return Point(a*x,a*y); }
	Point operator / (long double a){ return Point(x/a,y/a); }

	long double abs(){ return sqrt(norm()); }
	long double norm(){ return x*x + y*y; }

	bool operator<(const Point &p) const{
		return x != p.x? x < p.x: y < p.y;
	}

	bool operator == (const Point &p) const{
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}

	long double x,y;
};
typedef Point Vector;


long double table[2][100005];
vector<Point> V[2];

long double calc_dist(Point A,Point B){

	return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y));
}

long double Heron(Point A,Point B, Point C){

	long double a = calc_dist(A,B);
	long double b = calc_dist(B,C);
	long double c = calc_dist(C,A);
	long double s = (a+b+c)/2;

	return sqrt(s*(s-a)*(s-b)*(s-c));
}

long double norm(Vector a){
	return a.x*a.x+a.y*a.y;
}

long double abs(Vector a){
	return sqrt(norm(a));
}

long double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

long double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

long double calc_S(Point A,Point B,Point C){

	return abs(cross(B-A,C-A))/2;
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -1;
static const int ON_SEGMENT = 0;

int ccw(Point p0,Point p1,Point p2){

	Vector a = p1 - p0;
	Vector b = p2 - p0;

	if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
	if(cross(a,b) < -EPS)return CLOCKWISE;
	if(dot(a,b) < -EPS)return ONLINE_BACK;
	if(a.norm() < b.norm())return ONLINE_FRONT;

	return ON_SEGMENT;
}

void ConvexHull(Type type){

	vector<Point> UP,DOWN;

	UP.push_back(V[type][0]);
	DOWN.push_back(V[type][0]);

	table[type][0] = 0;

	for(int i = 1; i < V[type].size(); i++){

		table[type][i] = table[type][i-1];

		while(UP.size() > 1 && ccw(UP[UP.size()-2],UP[UP.size()-1],V[type][i]) == COUNTER_CLOCKWISE){

			table[type][i] -= calc_S(UP[UP.size()-2],UP[UP.size()-1],DOWN[DOWN.size()-1]);
			UP.pop_back();
		}

		while(DOWN.size() > 1 && ccw(DOWN[DOWN.size()-2],DOWN[DOWN.size()-1],V[type][i]) ==  CLOCKWISE){

			table[type][i] -= calc_S(DOWN[DOWN.size()-2],DOWN[DOWN.size()-1],UP[UP.size()-1]);
			DOWN.pop_back();
		}

		table[type][i] += calc_S(UP[UP.size()-1],DOWN[DOWN.size()-1],V[type][i]);

		UP.push_back(V[type][i]);
		DOWN.push_back(V[type][i]);
	}
}

int main(){

	int N;
	long double x,y;

	scanf("%d",&N);

	for(int i = 0; i < N; i++){
		cin >> x >> y;

		V[LEFT].push_back(Point(x,y));
		V[RIGHT].push_back(Point(x,y));
	}

	sort(V[LEFT].begin(),V[LEFT].end());
	sort(V[RIGHT].rbegin(),V[RIGHT].rend());

	ll ans = 9223372036854775807;

	ConvexHull(LEFT);
	ConvexHull(RIGHT);

	reverse(table[RIGHT],table[RIGHT]+N);

	for(int i = 0; i < N-1; i++){

		if(fabs(V[LEFT][i+1].x-V[LEFT][i].x) < EPS)continue;

		ans = min(ans,(ll)roundl(table[LEFT][i]+table[RIGHT][i+1]));
	}

	if(ans == 9223372036854775807){

		ans = 0;
	}

	printf("%lld\n",ans);

	return 0;
}



Measured memory_bytes: 19504