program farmeri;

uses Math;

type    koord=record
        x,y:real;
        end;

        //neez=array[1..2000] of koord;

var n:longint;
c:array[1..4] of integer;
data:array[0..2000] of koord;
limit:koord;

procedure Unos;
var
f:text;
i:integer;
tx, ty:real;
begin
assign(f, 'farmeri.in');
reset(f);
Readln(f, n);
for i:=1 to n do
        begin
        readln(f, tx, ty);
        data[i].x:=tx;
        data[i].y:=ty;
        end;
close(f);

end;

function maxK(switch:integer):integer;
var
maxr:real;
i, j, maxi:integer;
begin
maxi:=1;
if switch=1 then maxr:=data[1].x else maxr:=data[1].y;
if switch=1 then
        for i:=2 to n do if data[i].x>maxr then
                begin
                maxr:=data[i].x;
                maxi:=i;
                end else
        for j:=2 to n do if data[j].y>maxr then
                begin
                maxr:=data[j].y;
                maxi:=j;
                end;
maxK:=maxi;
end;

function minK(switch:integer):real;
var
minr:real;
i, j, mini:integer;
begin
mini:=1;
if switch=1 then minr:=data[1].x else minr:=data[1].y;
if switch=1 then
        begin
        for i:=2 to n do if data[i].x<minr then
                begin
                minr:=data[i].x;
                mini:=i;
                end;
        end
        else
        begin
        for j:=2 to n do if data[j].y<minr then
                begin
                minr:=data[j].y;
                mini:=j;
                end;
        end;
mink:=minr;
end;

procedure ReKoord;
var i:integer;
minx5, miny5:real;
begin
minx5:=mink(1);
miny5:=mink(2);
for i:=1 to n do
        begin
        data[i].x:=data[i].x-minx5;
        data[i].y:=data[i].y-miny5;
        end;
end;

function ToK(p, q:real):koord;
var tmp:koord;
begin
tmp.x:=p;
tmp.y:=q;
ToK:=tmp;
end;

function Rast(t1, t2:koord):real;
var tmp:real;
begin
tmp:=sqrt(sqr(t1.x-t2.x)+sqr(t1.y-t2.y));
rast:=tmp;
end;

function Closest(mode:integer):integer;
var
i, j, mini:integer;
minr:real;
ref:koord;
tmp:koord;
pass:boolean;
begin
case mode of
{dolelevo} 1:ref:=ToK(0, 0);
{doledesno}2:ref:=ToK(data[maxk(1)].x, 0);
{gorelevo} 3:ref:=ToK(0, data[maxk(2)].y);
{goredesno}4:ref:=ToK(data[maxk(1)].x, data[maxk(2)].y);
        end;


{if tb='b' then
        begin
        if lr='l' then ref:=ToK(0, 0) else
        if lr='r' then ref:=ToK(data[maxk('x')].x, 0);
        end else
if tb='t' then
        begin
        if lr='l' then ref:=ToK(0, data[maxk('y')].y) else
        if lr='r' then ref:=ToK(data[maxk('x')].x, data[maxk('y')].y);
        end;}

minr:=rast(ref, data[1]);
mini:=1;
for i:=2 to n do if Rast(ref, data[i])<minr then
                if mode=1 then
                        begin
                        minr:=Rast(ref, data[i]);
                        mini:=i;
                        end
                else
                        begin
                        pass:=true;
                        for j:=mode-1 downto 1 do if c[j]=i then pass:=false;
                        if pass then
                                begin
                                minr:=Rast(ref, data[i]);
                                mini:=i;
                                end;
                        end;

{if mode<1  then closest:=0 else
        begin
        minr:=rast(ref, data[1]);
        mini:=1;
        for i:=2 to n do if Rast(ref, data[i])<minr then
                begin
                minr:=Rast(ref, data[i]);
                mini:=i;
                end;
        for i:=1 to mode do
                if closest(mode-i)=closest(mode) then
                begin
                tmp:=data[closest(mode-i)];
                data[closest(mode-i)]:=0;
                closest:=closest(mode);
                end
                else closest:=mini;
        end;}
closest:=mini;
end;

function CLB(a,b:real):real;
begin
if a<b then clb:=a else clb:=b;
end;

function CGB(a,b:real):real;
begin
if a>b then cgb:=a else cgb:=b;
end;

function minkoo:koord;
var maxx, maxy:real;
begin
maxx:=data[c[1]].x;
maxy:=data[c[1]].y;
maxx:=CLB(data[c[2]].x, maxx);
maxx:=CLB(data[c[3]].x, maxx);
maxx:=CLB(data[c[4]].x, maxx);
maxy:=CLB(data[c[2]].y, maxy);
maxy:=CLB(data[c[3]].y, maxy);
maxy:=CLB(data[c[4]].y, maxy);
minkoo:=ToK(maxx, maxy);
end;

function maxkoo:koord;
var tmp:koord;
i:integer;
begin
tmp:=data[c[1]];
for i:=2 to 4 do
        begin
        tmp.x:=CGB(data[c[i]].x, tmp.x);
        tmp.y:=CGB(data[c[i]].y, tmp.y);
        end;
end;


procedure stickdown;
var
i:integer;
mink:koord;
begin
for i:=1 to 4 do c[i]:=closest(i);
mink:=minkoo;
for i:=1 to 4 do
        begin
        data[c[i]].x:=data[c[i]].x-mink.x;
        data[c[i]].y:=data[c[i]].y-mink.y;
        end;

end;

{function IsOver(ta, tl1, tl2:koord):integer; //1:ispod, 2:na, 3:iznad, 4:ne
var
k, n:real;
begin
if tl1.x-tl2.x=0 then
        begin
                if ta.x=tl1.x then IsOver:=2 else IsOver:=4
                end
else
        begin
        k:=(tl1.y-tl2.y)/(tl1.x-tl2.x);
        n:=tl1.y-k*tl1.x;
        if ta.y>(k*ta.x+n) then IsOver:=3 else
        if ta.y=(k*ta.x+n) then IsOver:=2 else IsOver:=1;
        end;
end;

function IsRight(ta, tl1, tl2:koord):integer; //1:levo, 2:na, 3:desno, 4:ne
var
k, n:real;
begin
if tl1.x-tl2.x=0 then
        begin
        if ta.x<tl1.x then IsRight:=1 else
        if ta.x=tl1.x then IsRight:=2 else IsRight:=3
        end
else
        begin
        k:=(tl1.y-tl2.y)/(tl1.x-tl2.x);
         n:=tl1.y-k*tl1.x;
        if k=0 then
                begin
                if ta.y=n then IsRight:=2 else IsRight:=4;
                end
        else
        if ta.x2((ta.y-n)/k) then IsRight:=1 else
        ta.x=((ta.y-n)/k) then IsRight:=2 else IsRight:=3;
        end;



end;}

function ef(k, n, x:real):real;
begin
ef:=k*x+n;
end;

function calculus:real;
var p1, p2, p3:real;
iks1, ips1, iks2, ips2, midy, k, n:real;
begin
p1:=abs((data[c[3]].y-data[c[1]].y)*(data[c[1]].x-data[c[3]].x)/2);
p3:=abs((data[c[2]].y-data[c[4]].y)*(data[c[2]].x-data[c[4]].x)/2);
if data[c[4]].x<data[c[2]].x then
        begin
        iks2:=data[c[4]].x;
        ips2:=data[c[4]].y;
        end
        else
        begin
        iks2:=data[c[2]].x;
        ips2:=data[c[2]].y;
        end;
if data[c[1]].x>data[c[3]].x then
        begin
        iks1:=data[c[1]].x;
        ips1:=data[c[1]].y;
        end
        else
        begin
        iks1:=data[c[3]].x;
        ips1:=data[c[3]].y;
        end;
                                  {}
if (data[c[1]].x=data[c[2]].x) or (data[c[1]].x=data[c[4]].x) then p2:=0 else
        begin
        k:=(data[c[1]].y-data[c[2]].y)/(data[c[1]].x-data[c[2]].x);
        n:=(data[c[1]].y-k*data[c[1]].x);
        if ef(k, n, data[c[1]].x) >
        ef(k, n, data[c[2]].x)
        then midy:=ef(k, n, data[c[2]].x)
        else
        midy:=ef(k, n, data[c[1]].x);

        k:=(data[c[1]].y-data[c[4]].y)/(data[c[1]].x-data[c[4]].x);
        n:=(data[c[1]].y-k*(data[c[1]].x));

        p2:=abs((iks1-iks2)*(ips1+ips2)/2)-abs((iks1-iks2)*(ef(k, n, iks1)-midy+ef(k, n, iks2)-midy));
        end;
calculus:=p1+p2+p3;


{if (data[c[4]].x>data[c[1]].x) and (data[c[1]].y<data[c3].y) then
        begin
        p1:=
        end; }
end;

procedure Output;
var wrt:string;
num:longint;
reta:real;
tmp:char;
f:text;
begin
reta:=calculus;
num:=Round(reta*1000);
Str(num, wrt);
tmp:=wrt[length(wrt)];
wrt:=wrt+tmp;
wrt[length(wrt)-2]:=wrt[length(wrt)-3];
wrt[length(wrt)-3]:=wrt[length(wrt)-4];
wrt[length(wrt)-4]:='.';

assign(f, 'farmeri.out');
rewrite(f);
writeln(f, wrt);
close(f);
end;





//num:=reta*1000 div 1000;



begin
data[0]:=ToK(-1, -1);
Unos;
ReKoord;
stickdown;
Output;


end.
