program farmeri;

const
   maxN = 2000;
   eps = 0.000000001;

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 real;
   L, R : mySet;

procedure processCoef(i, j : integer; var a, b, c : real);
var
   n, k : real;
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 : real) : real;
begin
   distance := abs(a*x[i] + b*y[i] + c) / (sqrt( sqr(a) + sqr(b) ));
end;

function side(i, j : integer; t : integer) : Boolean;
begin
   side := (y[t]-y[i])*(x[j]-x[i]) > (x[t]-x[i])*(y[j]-y[i]);
end;

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

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

function maxD(X : mySet; i, j : integer) : real;
var
  a, b, c, tmp, d : real;
  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) : real;
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);

  //      for t := 1 to n do
 //    write(ord(L[t]));  writeln;
 //  for t := 1 to n do
 //    write(ord(R[t]));  writeln;


        maxLD := maxD(L, i, j);
        maxRD := maxD(R, i, j);
        p := 0.5 * length(i, j) * (maxRD + maxLD); //writeln(p : 0 : 3, ' ', maxp : 0 : 2); readln;
        if p > maxP then
          maxP := p;
      end;

{   split(L, R, 1, 6);
   for i := 1 to n do
     write(ord(L[i]));  writeln;
   for i := 1 to n do
     write(ord(R[i]));  writeln;        }
       // writeln(i, ' ', j);
       // readln;
       // writeln(a : 0 : 2, ' ', b : 0 : 2, ' ', c : 0 : 2);

  // writeln(maxP : 0 : 3);


   writeln(fout, maxP : 0 : 3);

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




