program farmeri;

const
   maxN = 2000;
   eps = 0.00000001;

type
   mySet = array [1 .. maxN] of Boolean;

var
   fin, fout : text;
   n, i, j, t : integer;
   a, b, c, p, maxP, maxLD, maxRD : real;
   x, y : array [1 .. maxN] of extended;
   L, R : mySet;

procedure processCoef(i, j : integer; var a, b, c : extended);
var
   n, k : extended;
begin
   if (abs(x[i]-x[j]) < eps) then begin
      a := 1.0;
      b := 0;
      c := (-1)*x[i];
   end
   else begin
      k := (y[i]-y[j]) / (x[i]-x[j]);
      n := (x[i]*y[j]-y[i]*x[j]) / (x[i]-x[j]);
      a := k;
      b := -1;
      c := n;
   end;
end;

function distance(i : integer; a, b, c : extended) : extended;
begin
   distance := abs(a*x[i] + b*y[i] + c) / (sqrt( sqr(a) + sqr(b) ));
end;

function side(i, j : integer; t : integer) : integer;
var
  l, r : extended;
begin
   l := (y[t]-y[i])*(x[j]-x[i]);
   r := (x[t]-x[i])*(y[j]-y[i]);
   if abs(l-r) < eps then
     side := 0
   else
     if l > r then
       side := 1
     else
       side := -1;
end;

procedure split(var A, B : mySet; i, j : integer);
var
   id, idx, relside, tmp : integer;
   //relSide : Boolean;
begin
   fillchar(A, sizeof(A), false);
   fillchar(B, sizeof(B), false);

   id := 1;
   while ( (id = i) or (id = j) or (side(i, j, id) = 0) ) do inc(id);
   A[id] := true;
   relSide := side(i, j, id);
   for idx := 1 to n do
     if (idx <> i) and (idx <> j) then begin
       tmp := side(i, j, idx);
       if tmp = relSide then
         A[idx] := true
       else
         if tmp <> 0 then
           B[idx] := true;
       end;
end;

function maxD(X : mySet; i, j : integer) : extended;
var
  a, b, c, tmp, d : extended;
  idx : integer;
begin
  tmp := 0.0;
  for idx := 1 to n do
    if X[idx] then begin
      processCoef(i, j, a, b, c);
      d := distance(idx, a, b, c);
      if d > tmp then
        tmp := d;
    end;
  maxD := tmp;
end;

function length(i, j : integer) : extended;
begin
  length := sqrt( sqr(x[i]-x[j]) + sqr(y[i]-y[j]) );
end;

begin
   assign(fin, 'farmeri.in'); reset(fin);
   assign(fout, 'farmeri.out'); rewrite(fout);

   readln(fin, n);
   for i := 1 to n do
      readln(fin, x[i], y[i]);

   for i := 1 to n-1 do
      for j := i+1 to n do begin
        split(L, R, i, j);
        maxLD := maxD(L, i, j);
        maxRD := maxD(R, i, j);
        p := 0.5 * length(i, j) * (maxRD + maxLD);
        if p > maxP then
          maxP := p;
      end;

 //  writeln(maxP : 0 : 3);

   writeln(fout, maxP : 0 : 3);

   close(fin);
   close(fout);
end.




