program Project2;



{$APPTYPE CONSOLE}



uses

  SysUtils, Math;



type

st = record

x,y:extended;

end;

grt = record

x,y:integer;

h:extended;

fl:boolean;

end;

var

a:array[0..251] of st;

ms, ans, help: array[0..200000] of grt;

count, q, i,j,n,k,s,ii,jj,kk,kkk,u:integer;

answer, ferm:extended;

p1,p2,p3,v1,v2,ot:st;

g:array[0..260,0..260] of extended;
path, rk: array [1..10000] of integer;



function dist(x1,y1,x2,y2:extended):extended;

begin

dist := sqrt(sqr(x2-x1)+sqr(y2-y1));

end;



function dist2(o1,o2:st):extended;

begin

dist2 := sqrt(sqr(o2.x-o1.x)+sqr(o2.y-o1.y));

end;

procedure qsort (l,r: integer);



var

  i, j: integer;

  x:extended;

  y:grt;

begin

  i := l;

  j := r;

  x := ans[random(r-l+1)+l].h;

  repeat

    while (ans[i].h < x) do inc(i);

    while (x < ans[j].h) do dec(j);

      if (i <= j) then begin

        if (ans[i].h > ans[j].h) then begin

          y := ans[i];

          ans[i] := ans[j];

          ans[j] := y;

        end;

        inc(i);

        dec(j);

      end;

  until(i > j);

  if (l < j) then qsort(l, j);

  if (i < r) then qsort(i, r);

end;

function red(c,d: st): st;

begin

red.x :=d.x-c.x;

red.y :=d.y-c.y;

end;

procedure swapint(var a, b: integer);

var

c: integer;

begin

c := a;

a := b;

b := c;

end;

function area (c, d: st): extended;

begin

area := c.x * d.y - d.x * c.y;

end;

function torr(h1,h2,h3:st):st;

var

r12,r13,r23,s,a,b,c,a2,c2,b2,p,q,d:extended;

begin

  r12 := sqr(h1.x - h2.x) + sqr(h1.y - h2.y);

  r13 := sqr(h1.x - h3.x) + sqr(h1.y - h3.y);

  r23 := sqr(h2.x - h3.x) + sqr(h2.y - h3.y);

  v1 := red(h1, h2);

  v2 := red(h1, h3);

  s := area(v1, v2);

  d := (r12 + r13 + r23)/2 + sqrt(3)*abs(s);

  a := sqrt(3)*(p1.x*r23 + p2.x*r13+p3.x*r12);

  b := s*(p1.x+p2.x+p3.x);

  c := 3*((p1.y-p2.y)*(p1.x*p2.x+p1.y*p2.y) + (p3.y-p1.y)*(p1.x*p3.x+p1.y*p3.y) + (p2.y-p3.y)*(p2.x*p3.x+p2.y*p3.y));

  p := a-b+c;

  a2 := sqrt(3)*(p1.y*r23 + p2.y*r13+p3.y*r12);

  b2 := s*(p1.y+p2.y+p3.y);

  c2 := 3*((p1.x-p2.x)*(p1.x*p2.x+p1.y*p2.y) + (p3.x-p1.x)*(p1.x*p3.x+p1.y*p3.y) + (p2.x-p3.x)*(p2.x*p3.x+p2.y*p3.y));

  q := a2-b2-c2;

  torr.x := (p/(2*sqrt(3)*d));

  torr.y := (q/(2*sqrt(3)*d));

  end;

procedure swap(var a, b: st);

var

c: st;

begin

c := a;

a := b;

b := c;

end;

function leng(x3, y3: extended): extended;

begin

  leng := sqrt(sqr(x3) + sqr(y3));

end;



function check(x1, y1, x2, y2:extended):boolean;

var

p:extended;

begin

   p := (x1 * x2 + y1 * y2) /(leng(x1, y1) * leng(x2, y2));

   if (arccos(p) >= 2*pi/3) then check := false

   else check := true;

   writeln(arccos(p));

end;



procedure mak(v: integer);

begin

path[v] := v;

rk[v] := 0;

end;



function find(v: integer): integer;

begin

  if (v <> path[v]) then

    path[v] := find(path[v]);

  find := path[v];

end;



procedure un(a, b: integer);

begin

  a := find(a);

  b := find(b);

  if (a <> b) then begin

    if (rk[a] < rk[b]) then

      swapint (a, b);

    path[b] := a;

    if (rk[a] = rk[b]) then

      inc(rk[a]);

  end;

end;



procedure kryskal;

var

  i: integer;

begin

  q := 0;

  for i:=1 to n+1 do

    mak(i);

    answer:=0;

  for i:=1 to count do

    if find(ans[i].x)<>find(ans[i].y) then begin

      answer:=answer+ans[i].h;

      inc(q);

      ms[q] := ans[i];

      un(ans[i].x,ans[i].y);

    end;

end;



begin

  readln(n);

  for i := 1 to n do

  readln(a[i].x,a[i].y);

  for i := 1 to n do

    for j := i + 1 to n do

      g[i,j] := dist(a[i].x,a[i].y,a[j].x,a[j].y);

      kkk := 0;

  for i := 1 to n do

    for j := i + 1 to n do

      if (g[i,j] <> 0) then begin

        inc(kkk);

        help[kkk].x := i;

        help[kkk].y := j;

        help[kkk].h := g[i,j];

      end;

    s := 0;

  for i := 1 to n-2 do

    for j := i + 1 to n-1 do

      for k := j + 1 to n do  begin

      p1 := a[i];

      p2 := a[j];

      p3 := a[k];

      ii := i;

      jj := j;

      kk := k;

      if p1.x>p2.x then begin

        swap(p1, p2);

        swapint(ii, jj);

      end

      else if p1.x=p2.x then

        if p1.y>p2.y then begin

          swap(p1, p2);

          swapint(ii, jj);

      end;

      if p1.x>p3.x then begin

          swap(p1, p3);

           swapint(ii, kk);

      end

      else if p1.x=p3.x then

      if p1.y>p3.y then begin

        swap(p1, p3);

        swapint(ii, kk);

      end;

      if p2.y<p3.y then begin

        swap(p2, p3);

        swapint(jj, kk);

      end

      else if p2.y=p3.y then

        if p2.x>p3.x then begin

        swap(p2, p3);

        swapint(jj, kk);

      end;

      ot := torr(p1,p2,p3);

      ferm := sqrt(sqr(p1.x-ot.x)+sqr(p1.y-ot.y)) + sqrt(sqr(p2.x-ot.x)+sqr(p2.y-ot.y)) + sqrt(sqr(p3.x-ot.x)+sqr(p3.y-ot.y)) ;

      if (ferm>dist2(p1, p2)+dist2(p1, p3))or

      (ferm>dist2(p1, p3)+dist2(p2, p3))or

      (ferm>dist2(p1, p2)+dist2(p2, p3))then

       continue

      else begin

        for u := 1 to kkk do

          ans[u] := help[u];

          ans[kkk+1].x :=  ii;

          ans[kkk+2].x :=  jj;

          ans[kkk+3].x :=  kk;

          ans[kkk+1].y :=  kkk+1;

          ans[kkk+2].y :=  kkk+1;

          ans[kkk+3].y :=  kkk+1;

          ans[kkk+1].h :=  dist2(ot,p1);

          ans[kkk+2].h :=  dist2(ot,p2);

          ans[kkk+3].h :=  dist2(ot,p3);

          ans[kkk+1].fl :=  true;

          ans[kkk+2].fl :=  true;

          ans[kkk+3].fl :=  true;

        end;

        qsort(1,kkk+3);

    end;
       for u := 1 to q do
        writeln(ms[u].x, ' ', ms[u].y, ' ', ms[u].h);
      {  for u := 1 to kkk+3 do

        writeln(ans[u].x,' ',ans[u].y,' ',ans[u].h,' ',ans[u].fl) ;
       }
  writeln(s);

  readln;

  readln;

end.