#include<bits/stdc++.h>
using namespace std;
struct slog
{
    long long x;
    long long y;
};
slog p0; /// NAJMANJA TACKA
stack<slog> S; /// STEK
slog tacke[100050];
slog niz[100050];
slog niz_za_povrsinu[100050];
long long ntemp, P, res, zbir, br;
long long n;
slog nextToTop() /// NADJI ONU KOJA JE SLEDECA NA STEKU
{
   slog p = S.top();
   S.pop();
   slog res = S.top();
   S.push(p);
   return res;
}

void swap(slog p1, slog p2)
{
   slog temp = p1;
   p1 = p2;
   p2 = temp;
}

long long UDALJENOST(slog p1, slog p2)
{
   return (p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y);
}

long long POVRSINA2()
{
   for(int i=1; i<br; i++)
   {
      zbir += (niz_za_povrsinu[i].x/2) *   niz_za_povrsinu[i+1].y; /// POVECAM ZBIR OVDE
      zbir -= (niz_za_povrsinu[i+1].x/2) * niz_za_povrsinu[i].y; /// VAMO GA SMANJIM
   }

   zbir += (niz_za_povrsinu[br].x/2) * niz_za_povrsinu[1].y;
   zbir -= (niz_za_povrsinu[1].x/2) * niz_za_povrsinu[br].y;
   zbir = abs(zbir);

   cout << zbir << endl;
   return zbir;
}

long long POVRSINA()
{
   for(int i=1; i<br; i++)
   {
      zbir += (niz_za_povrsinu[i].x/2) *   niz_za_povrsinu[i+1].y; /// POVECAM ZBIR OVDE
      zbir -= (niz_za_povrsinu[i+1].x/2) * niz_za_povrsinu[i].y; /// VAMO GA SMANJIM
   }

   zbir += (niz_za_povrsinu[br].x/2) * niz_za_povrsinu[1].y;
   zbir -= (niz_za_povrsinu[1].x/2) *  niz_za_povrsinu[br].y;
   zbir = abs(zbir);

   cout << zbir << endl;
   return zbir;
}

long long ORIJENTACIJA(slog p, slog q, slog r)
{
   long long val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);

   if (val == 0)
      return 0;  // collinear

   if (val > 0)
      return 1;

   else
      return 2; // clock or counterclock wise
}

int cmp(const void* vp1, const void* vp2)
{
   slog *p1 = (slog *)vp1;
   slog *p2 = (slog *)vp2;

   long long o = ORIJENTACIJA(p0, *p1, *p2);

   if (o == 0)
   {
      if(UDALJENOST(p0, *p2) >= UDALJENOST(p0, *p1))
         return -1;

      else
         return 1;
   }

   if(o == 2)
      return -1;
   else
      return 1;
}

void SPREMANJE()
{
   long long ymin = tacke[1].y;
   long long mini = 1;

   for (int i = 1; i <= n; i++)
   {
      long long y = tacke[i].y;

      if ((tacke[i].y < ymin) or (ymin == tacke[i].y and tacke[i].x < tacke[mini].x))
      {
         ymin = tacke[i].y;
         mini = i;
      }
   }

   long long temp1 = tacke[1].x;
   long long temp2 = tacke[1].y;

   tacke[1].x = tacke[mini].x;
   tacke[1].y = tacke[mini].y;

   tacke[mini].x = temp1;
   tacke[mini].y = temp2;

   p0 = tacke[1];
   ntemp = n;
   qsort(&tacke[2], ntemp-1, sizeof(slog), cmp); /// SORTIRAM KA PRVOM CLANU NIZA, KOLIKO NJIH IMA, KOJA MU JE VELICINA U BAJTOVIMA I cmp FUNKCIJA
}

void OMOTAC(int iskljuci)
{
   while(!S.empty())
      S.pop();

   S.push(tacke[1]);
   S.push(tacke[2]);
   S.push(tacke[3]);

   for(int i = 4; i <= n; i++)
   {
      if(i != iskljuci) /// PRESKACEM
      {
         while (S.size()>1 and ORIJENTACIJA(nextToTop(), S.top(), tacke[i]) != 2)
            S.pop();
         S.push(tacke[i]);
      }
   }

   br = 0;

   while (!S.empty())
   {
      br++;

      slog p = S.top();
      niz_za_povrsinu[br].x = p.x;
      niz_za_povrsinu[br].y = p.y;
      //cout << niz[br].x << " " << niz[br].y << endl;
      S.pop();
   }
   P = POVRSINA();
   res = min(res, P);
}

void OMOTAC3() /// PRESKACE 3
{
   while(!S.empty())
      S.pop();
   S.push(tacke[1]);
   S.push(tacke[2]);
   S.push(tacke[4]);

   for(int i = 5; i <= n; i++)
   {
      while (S.size()>1 and ORIJENTACIJA(nextToTop(), S.top(), tacke[i]) != 2)
         S.pop();
      S.push(tacke[i]);
   }

   br = 0;

   while(!S.empty())
   {
      br++;

      slog p = S.top();
      niz_za_povrsinu[br].x = p.x;
      niz_za_povrsinu[br].y = p.y;
      //cout << niz[br].x << " " << niz[br].y << endl;
      S.pop();
   }
   P = POVRSINA();
   res = min(res, P);
}

void OMOTAC2() /// PRESKACE 2
{
   while(!S.empty())
      S.pop();
   S.push(tacke[1]);
   S.push(tacke[3]);
   S.push(tacke[4]);

   for(int i = 5; i <= n; i++)
   {
      while (S.size()>1 and ORIJENTACIJA(nextToTop(), S.top(), tacke[i]) != 2)
         S.pop();
      S.push(tacke[i]);
   }

   br = 0;

   while(!S.empty())
   {
      br++;

      slog p = S.top();
      niz_za_povrsinu[br].x = p.x;
      niz_za_povrsinu[br].y = p.y;
      //cout << niz[br].x << " " << niz[br].y << endl;
      S.pop();
   }
   P = POVRSINA();
   res = min(res, P);
}

void OMOTAC1() /// PRESKACE 1
{
   //cout << "TACKE SORTIRANE PO NOVOM NAJMANJEM" << endl;
   //for(int i=1; i<n; i++)
   //   cout << niz[i].x << " " << niz[i].y << endl;
   //return;
   while(!S.empty())
      S.pop();
   S.push(niz[1]);
   S.push(niz[2]);
   S.push(niz[3]);

   for(int i = 4; i < n; i++)
   {
      while (S.size()>1 and ORIJENTACIJA(nextToTop(), S.top(), niz[i]) != 2)
         S.pop();
      S.push(niz[i]);
   }

   br = 0;

   while(!S.empty())
   {
      br++;

      slog p = S.top();
      niz_za_povrsinu[br].x = p.x;
      niz_za_povrsinu[br].y = p.y;
      //cout << niz[br].x << " " << niz[br].y << endl;
      S.pop();
   }
   P = POVRSINA2();
   res = min(res, P);
}

void SPREMANJE2()
{
   ntemp = 0;
   for(int i=2; i<=n; i++)
   {
      ntemp++;
      niz[ntemp].x = tacke[i].x;
      niz[ntemp].y = tacke[i].y;
      //cout << ntemp << " " << tacke[i].x << " " << tacke[i].y << endl;
   }


   long long ymin = niz[1].y;
   long long mini = 1;

   for (int i = 1; i < n; i++)
   {
      long long y = niz[i].y;

      if ((niz[i].y < ymin) or (ymin == niz[i].y and niz[i].x < niz[mini].x))
      {
         ymin = niz[i].y;
         mini = i;
      }
   }

   long long temp1 = niz[1].x;
   long long temp2 = niz[1].y;

   niz[1].x = niz[mini].x;
   niz[1].y = niz[mini].y;

   niz[mini].x = temp1;
   niz[mini].y = temp2;

   p0 = niz[1];
   qsort(&niz[2], ntemp-1, sizeof(slog), cmp); /// SORTIRAM KA PRVOM CLANU NIZA, KOLIKO NJIH IMA, KOJA MU JE VELICINA U BAJTOVIMA I cmp FUNKCIJA

}

long long SET_POVRSINA(slog prvi, slog drugi, slog treci)
{
   long long SABERI = 0;

   SABERI = prvi.x * drugi.y + drugi.x * treci.y + treci.x * prvi.y - drugi.x*prvi.y - treci.x*drugi.y - prvi.x*treci.y;
   SABERI = abs(SABERI);
   SABERI = SABERI / 2;

   return SABERI;
}

int main()
{
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);

   cin >> n;
   res = 1000000000000000000;
   for(int i=1; i<=n; i++)
      cin >> tacke[i].x >> tacke[i].y;

   if(n == 4)
   {
      slog prvi;
      slog drugi;
      slog treci;

      prvi.x = tacke[1].x;
      prvi.y = tacke[1].y;
      drugi.x = tacke[2].x;
      drugi.y = tacke[2].y;
      treci.x = tacke[3].x;
      treci.y = tacke[3].y;

      P = SET_POVRSINA(prvi, drugi, treci);
      res = P;

      prvi.x = tacke[1].x;
      prvi.y = tacke[1].y;
      drugi.x = tacke[2].x;
      drugi.y = tacke[2].y;
      treci.x = tacke[4].x;
      treci.y = tacke[4].y;

      P = SET_POVRSINA(prvi, drugi, treci);
      res = min(res, P);

      prvi.x = tacke[1].x;
      prvi.y = tacke[1].y;
      drugi.x = tacke[3].x;
      drugi.y = tacke[3].y;
      treci.x = tacke[4].x;
      treci.y = tacke[4].y;

      P = SET_POVRSINA(prvi, drugi, treci);
      res = min(res, P);

      prvi.x = tacke[2].x;
      prvi.y = tacke[2].y;
      drugi.x = tacke[3].x;
      drugi.y = tacke[3].y;
      treci.x = tacke[4].x;
      treci.y = tacke[4].y;

      P = SET_POVRSINA(prvi, drugi, treci);
      res = min(res, P);

      cout << res << endl;
      return 0;
   }


   SPREMANJE();

   for(int i=4; i<=n; i++)
   {
      cout << endl;
      OMOTAC(i);
   }

   cout << endl;
   OMOTAC3(); /// ISKLJUCIVANJE TROJKE
   cout << endl;
   OMOTAC2();

   SPREMANJE2();
   cout << endl;
   OMOTAC1();
   cout << res << "\n";
   return 0;
}
/*

ULAZ:
6
2 4
4 6
14 8
8 6
12 4
6 2

IZLAZ:
*/