// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



typedef long long LL;

inline LL sqr(const LL &v) { return v * v; }



struct PT

{

	LL x, y;

	PT(LL x = 0, LL y = 0) : x(x), y(y) {}

	PT operator+(const PT &d) const { return PT(x + d.x, y + d.y); }

	PT& operator+=(const PT &d) { x += d.x, y += d.y; return *this; }

	PT operator-(const PT &d) const { return PT(x - d.x, y - d.y); }

	PT& operator-=(const PT &d) { x -= d.x, y -= d.y; return *this; }

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

};



LL norm2(const PT &v) { return sqr(v.x) + sqr(v.y); }

LL norm2(const PT &p1, const PT &p2) { return norm2(p1 - p2); }

LL vect(const PT &v1, const PT &v2) { return v1.x * v2.y - v2.x * v1.y; }

LL vect(const PT &p, const PT &p1, const PT &p2) { return vect(p1 - p, p2 - p); }



const int maxn = 100100;

int n, hn1, hn2, xn, x[maxn];

LL area, db1[maxn], db2[maxn];

PT p[maxn], h1[maxn], h2[maxn];



int main()

{

	int n;

	scanf("%d", &n);

	for (int i = 0; i < n; ++i) scanf("%lld%lld", &p[i].x, &p[i].y), x[xn++] = p[i].x;

	sort(p, p + n);

	sort(x, x + xn), xn = unique(x, x + xn) - x;

	hn1 = hn2 = area = 0;

	for (int i = 0, j; i < n;) {

		for (j = i; j < n; ++j) {

			if (p[i].x != p[j].x) break;

			for (; hn1 >= 2 && vect(h1[hn1 - 2], h1[hn1 - 1], p[j]) <= 0; --hn1)

				area -= vect(h1[hn1 - 2], h1[hn1 - 1]);

			if (hn1) area += vect(h1[hn1 - 1], p[j]);

			h1[hn1++] = p[j];

			for (; hn2 >= 2 && vect(p[j], h2[hn2 - 1], h2[hn2 - 2]) <= 0; --hn2)

				area -= vect(h2[hn2 - 1], h2[hn2 - 2]);

			if (hn2) area += vect(p[j], h2[hn2 - 1]);

			h2[hn2++] = p[j];

		}

		int id = lower_bound(x, x + xn, p[i].x) - x + 1;

		db1[id] = area;

		i = j;

	}

	hn1 = hn2 = area = 0;

	for (int i = n - 1, j; i >= 0;) {

		for (j = i; j >= 0; --j) {

			if (p[i].x != p[j].x) break;

			p[j].x = -p[j].x;

			for (; hn1 >= 2 && vect(h1[hn1 - 2], h1[hn1 - 1], p[j]) <= 0; --hn1)

				area -= vect(h1[hn1 - 2], h1[hn1 - 1]);

			if (hn1) area += vect(h1[hn1 - 1], p[j]);

			h1[hn1++] = p[j];

			for (; hn2 >= 2 && vect(p[j], h2[hn2 - 1], h2[hn2 - 2]) <= 0; --hn2)

				area -= vect(h2[hn2 - 1], h2[hn2 - 2]);

			if (hn2) area += vect(p[j], h2[hn2 - 1]);

			h2[hn2++] = p[j];

			p[j].x = -p[j].x;

		}

		int id = lower_bound(x, x + xn, p[i].x) - x + 1;

		db2[id] += area;

		i = j;

	}

	LL ans = 8e18;

	for (int i = 0; i <= xn; ++i) ans = min(ans, db1[i] + db2[i + 1]);

	printf("%lld\n", (ans + 1) / 2);

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.792892728190328x):
#include <bits/stdc++.h>

using namespace std;



struct pt {

	int x, y;

	pt() {}

	pt(int x, int y) : x(x), y(y) {}

	void output () {

		cerr << x << "," << y << endl;

	}

};



const int N = 110000;

pt a[N];

int x[N], xn;



bool operator < (const pt &p1, const pt & p2) {

	if (p1.x != p2.x) return p1.x < p2.x;

	return p1.y < p2.y;

}



pt operator - (pt p1, pt p2) {

	return pt(p1.x - p2.x, p1.y - p2.y);

}



long long vect(pt p1, pt p2) {

	return 1LL * p1.x * p2.y - 1LL * p2.x * p1.y;

}



long long vect(pt p, pt p1, pt p2) {

	return vect(p1 - p, p2 - p);

}



pt up[N], down[N]; int upn, downn;

long long le[N], ri[N];



int main() {

	ios_base::sync_with_stdio(0);

	int n; cin >> n;

	for (int i = 0; i < n; i++) cin >> a[i].x >> a[i].y;

	for (int i = 0; i < n; i++) x[xn++] = a[i].x;

	sort(a, a + n);

	sort(x, x + n);

	xn = unique(x, x + n) - x;

	upn = downn = 0;

	int now = 0;

	long long area = 0;

	for (int i = 0; i < xn; i++) {

		for (; a[now].x == x[i] && now < n; now++) {

			while (upn > 1 && vect(up[upn - 2], up[upn - 1], a[now]) <= 0) {

				area -= vect(up[upn - 2], up[upn - 1]);

				upn--;

			}

			if (upn) area += vect(up[upn - 1], a[now]);

			up[upn++] = a[now];

			while (downn > 1 && vect(a[now], down[downn - 1], down[downn - 2]) <= 0) {

				area -= vect(down[downn - 1], down[downn - 2]);

				downn--;

			}

			if (downn) area += vect(a[now], down[downn - 1]);

			down[downn++] = a[now];

		}

		le[i] = area;

	}

	upn = downn = 0;

	area = 0;

	now = n-1;

	for (int i = xn; i >= 0; i--) {

		for (; a[now].x == x[i] && now >= 0; now--) {

			while (upn > 1 && vect(up[upn - 2], up[upn - 1], a[now]) <= 0) {

				area -= vect(up[upn - 2], up[upn - 1]);

				upn--;

			}

			if (upn) area += vect(up[upn - 1], a[now]);

			up[upn++] = a[now];

			while (downn > 1 && vect(a[now], down[downn - 1], down[downn - 2]) <= 0) {

				area -= vect(down[downn - 1], down[downn - 2]);

				downn--;

			}

			if (downn) area += vect(a[now], down[downn - 1]);

			down[downn++] = a[now];

		}

		ri[i] = area;

	}

	long long ans = ri[0];

	for (int i = 0; i < xn; i++) ans = min(ans, le[i] + ri[i + 1]);

	cout << (ans+1)/2 << endl;

	return 0;

}