program trijsturi;
{ Tiek ievadīti vienādsānu taisnleņķa trijstūri, jānoskaidro to
 apvienojuma laukums.
 c 2002, Mārtiņš Opmanis
}

type
 TElements = ^Elements;
  Elements = object
              x : longint; {x koord vērtība  vai  virziena koef. 0 ja horiz  vai  -1 ja dilst}
              y : longint;
              mala : longint;
              ieprieks, nakosais, draugs : TElements;
              constructor Izveido(x_,y_,m_: longint; dr : TElements);
             end;

  TSaraksts = ^Saraksts;
  Saraksts = object
              pirmais : TElements;
              el_skaits : integer;
              constructor Izveido;
              procedure Pievieno(el_ko, el_aiz_kura : TElements);
              procedure Pievieno_kur_vajag(el_ko : TElements; rezims : byte);
              function  Izmet(el : TElements; tikai_atkabini : boolean) : TElements;
             end;

var
 f : Text;
 i, j, n, x, y, mala, x_tagad, x_starpa, Dubsumma : longint;
 el, el_tagad, el_y, el1, el2 : TElements;
 x_sar, y_sar : TSaraksts;
 nogr_kopgarums, x_nobide_min, x_nob : longint;
 nogr_skaits, pedejais_sakuma_y, nogr_sakuma_y : longint;
 sakumpunktu_skaits : longint;
 sakums_ir : boolean;

label
 viss;

{-------------------------------------------------------------------------------------}
constructor Elements.Izveido(x_,y_,m_: longint; dr : TElements);
 begin
  x := x_; y := y_; mala := m_; draugs := dr;
  ieprieks := nil;  nakosais := nil;
 end;
{-------------------------------------------------------------------------------------}
constructor Saraksts.Izveido;
 begin
  pirmais := nil; el_skaits := 0;
 end;
{-------------------------------------------------------------------------------------}
 procedure Saraksts.Pievieno(el_ko, el_aiz_kura : TElements);
  begin
   if el_aiz_kura<>nil {nav pirmais}
    then
     begin
      el_ko^.nakosais := el_aiz_kura^.nakosais;
      el_ko^.ieprieks := el_aiz_kura;
      el_aiz_kura^.nakosais := el_ko;
      if el_ko^.nakosais<>nil then (el_ko^.nakosais)^.ieprieks := el_ko;
     end
    else {ir pirmais}
     begin
      el_ko^.nakosais := pirmais;
      if pirmais<>nil then pirmais^.ieprieks := el_ko;
      pirmais := el_ko;
     end;
   Inc(el_skaits);
  end;
{-------------------------------------------------------------------------------------}
  function Ir_jabut_pirms(el_kam,el_pirms_kaa : TElements; rezims : byte) : boolean;
   begin
    Ir_jabut_pirms := false;
    case rezims of
     1 : if el_pirms_kaa^.x>=el_kam^.x then Ir_jabut_pirms := true;
     2 : begin
          if el_pirms_kaa^.y<el_kam^.y
           then Ir_jabut_pirms := true
           else
            if (el_pirms_kaa^.y=el_kam^.y) and (el_pirms_kaa^.x<=el_kam^.x)
             then Ir_jabut_pirms := true
             else;
         end;
    end; {case}
   end;
{-------------------------------------------------------------------------------------}
  procedure Saraksts.Pievieno_kur_vajag(el_ko : TElements; rezims : byte);
  {režīms : 1 - trijstūra x saraksts, 2 - virsotņu y saraksts}
  var
   el_pirms, el_aiz : TElements;
  begin
   {Atrod īsto vietu}
   el_pirms := nil;
   el_aiz := pirmais;
   while el_aiz<>nil do
    begin
     if Ir_jabut_pirms(el_ko,el_aiz,rezims) then break;
     el_pirms := el_aiz;
     el_aiz := el_aiz^.nakosais;
    end;
   Pievieno(el_ko,el_pirms);
  end;
{-------------------------------------------------------------------------------------}
  function Saraksts.Izmet(el : TElements; tikai_atkabini : boolean) : TElements;
   begin
    {Jāsasien atlikums}
    if el^.ieprieks<>nil {nav sākums}
     then (el^.ieprieks)^.nakosais := el^.nakosais
     else pirmais := el^.nakosais;
    if el^.nakosais<>nil {nav beidzamais}
     then (el^.nakosais)^.ieprieks := el^.ieprieks
     else;
    Dec(el_skaits);
    if tikai_atkabini
     then Izmet := el
     else
      begin
       Dispose(el);
       Izmet := nil;
      end;
   end;
{-------------------------------------------------------------------------------------}
 procedure Pievieno_malu(ell : TElements);
 var el, el1 : TElements;
  begin
   with ell^ do
    begin
     New(el,Izveido(0,y,0,nil));          y_sar^.Pievieno_kur_vajag(el, 2);
     New(el1,Izveido(-1,y+mala,mala,el)); y_sar^.Pievieno_kur_vajag(el1, 2);
    end;
  end;
{-------------------------------------------------------------------------------------}

begin

 Dubsumma := 0;
 New(x_sar,Izveido);

 Assign(f,'tr.in');
 Reset(f);
 Readln(f,n);
 for i:=1 to n do
  begin
   Readln(f,x,y,mala);
   New(el,Izveido(x,y,mala,nil));
   x_sar^.Pievieno_kur_vajag(el, 1);
  end;
 Close(f);

 New(y_sar,Izveido);
 el_tagad := x_sar^.pirmais;

REPEAT

 x_tagad := el_tagad^.x;
 while (el_tagad<>nil) and (x_tagad=el_tagad^.x) do
  begin
   if el_tagad^.mala>0 then Pievieno_malu(el_tagad);
   x_sar^.Izmet(el_tagad, false);
   el_tagad := x_sar^.pirmais;
  end;

 {Ja ne x, ne y sarakstos vairs nav elementu, tad viss}
  if (x_sar^.el_skaits + y_sar^.el_skaits = 0) then goto viss;

 {Izejam cauri visam y sarakstam un aprēķinam nogriežņa kopgarumu,
  nogriežņu skaitu un nākošo x krustpunktu}

 if y_sar^.el_skaits>0
  then
   BEGIN
    nogr_kopgarums := 0;
    nogr_skaits := 0;
    sakumpunktu_skaits := 0;
    sakums_ir := false;
    x_nobide_min := 1000000000;

 el_y := y_sar^.pirmais;
 while el_y<>nil do
  begin
   if el_y^.x = -1
    then
     begin
      Inc(sakumpunktu_skaits);
      pedejais_sakuma_y := el_y^.y;
      if not sakums_ir
       then
        begin
         sakums_ir := true;
         nogr_sakuma_y := pedejais_sakuma_y;
        end
       else;
     end
    else
     begin
      Dec(sakumpunktu_skaits);
      x_nob := pedejais_sakuma_y - el_y^.y;
      if x_nob<x_nobide_min then x_nobide_min := x_nob;

      if sakumpunktu_skaits=0
       then  {Lielā nogriežņa beigas}
        begin
         sakums_ir := false;
         Inc(nogr_kopgarums,nogr_sakuma_y - el_y^.y);
         Inc(nogr_skaits);
        end;
     end;

    el_y := el_y^.nakosais;
  end;

 if x_nobide_min>0
  then
   begin
    New(el,Izveido(x_tagad+x_nobide_min,0,0,nil)); {Pazīme, ka te būs jāpārrēķina}
    x_sar^.Pievieno_kur_vajag(el, 1);
   end;

 {Ņem nākošo x un sarēķina pašreizējo (pēdējās pārejas) pienesumu
  Vienmēr būs, jo kāds elements apzīmē trīsstūra beigas.}
 el_tagad := x_sar^.pirmais;
 x_starpa := el_tagad^.x - x_tagad;

 if nogr_skaits>0  {Varbūt ir garš tukšums bez trīsstūriem}
  then Inc(Dubsumma,x_starpa*(nogr_kopgarums*2 - nogr_skaits*x_starpa));

 {Pārrēķinam vecos nogriežņus un izravējam nevajadzīgos (tos trīsstūrus, kas sagājuši 0)}
 el1 := y_sar^.pirmais;
 while el1<>nil do
  begin
   with el1^ do
    begin
     el2 := nakosais;
     if x=-1
      then
       begin
        Dec(mala,x_starpa);
        if mala=0 then
                   begin
                    {Draugs var būt tieši aiz, tāpēc šeit drusku citādāk}
                    y_sar^.Izmet(draugs, false);
                    el2 := nakosais;
                    y_sar^.Izmet(el1, false);
                   end
                  else
                   Dec(y, x_starpa);
       end;
    end;
   el1 := el2;
  end;

 {Vajadzētu pārrakt y sarakstu (jo sakārtojums, iespējams, ir mainījies)}
 el1 := y_sar^.pirmais;
 while el1<>nil do
  begin
   el2 := el1^.nakosais;
   if (el2<>nil) and (not Ir_jabut_pirms(el1,el2,2))
    then y_sar^.Pievieno_kur_vajag(y_sar^.Izmet(el2,true),2) {Pārliek derīgā vietā}
    else el1 := el2;  {Iet tālāk}
  end;

 END; {y netukšs}

UNTIL FALSE;

viss:
 Assign(f,'tr.out');
 Rewrite(f);
 write(f,Dubsumma div 2); if Dubsumma mod 2 = 1 then writeln(f,'.5') else writeln(f,'.0');
 Close(f);

end.