{$M 65520,0,655360}
program siustuvai_ir_imtuvas;
  { 137 u‘davinys }
  const MAX_N = 20; { maksimalus si—stuv— skai‡ius }
        LAIK = 200; { pranežimo perdavimo laikas }
  type siustuv = array [1..MAX_N] of integer;
       siustuv_l = array [1..MAX_N] of boolean;
       lentele = array [1..MAX_N, 1..LAIK] of integer;
       imtuvas = array [1..LAIK*MAX_N] of boolean;

  { ‘emiau suražyti globalieji kintamieji }
  var n: integer; { si—stuv— skai‡ius }
      t, l, p: siustuv; { si—stuv— charakteristikos }

      skl: lentele; { rodo kada imtuv… pasiekia kiekvieno }
      { si—stuvo signalai, jei si—stuvas jungiamas nuliniu momentu }

{ -----------------------------------------------------------}
  procedure skleistine (var skl: lentele);
  { kada imtuv… pasiekia kiekvieno si—stuvo signalai }
  { jei si—stuvas jungiamas nuliniu laiko momentu }
    var k, sek, sign: integer;
  begin
    for k := 1 to n do
      for sign := 1 to LAIK do
        skl[k, sign] := 0;
    for k := 1 to n do
      begin
        skl[k, 1] := l[k];
        sek := l[k];
        for sign := 2 to p[k] do
          begin
            sek := sek + t[k];
            skl[k, sign] := sek;
         end
      end;
  end; { skleistin‚ }
{ -----------------------------------------------------------}
  procedure ijungti (k, sek: integer;
                    var imt: imtuvas; var galima: boolean);
  { k-t…j si—stuv… bando jungti laiko momentu sek  }
  { jei galima tai padaryti, tai pakeiÑiamas masyvas imt }
   var sign, i: integer;
  begin
    sign := 1;
    galima := true;
    while (skl[k, sign] <> 0) and galima do
      begin
        if imt[sek + skl[k, sign]]  { jei vieta u‘imta }
           then begin { atstatome atgal }
                  for i := sign-1 downto 1 do
                    imt[sek + skl[k, i]] := false;
                  galima := false
               end
           else imt[sek + skl[k, sign]] := true;
        sign := sign + 1
      end;
  end; { ijungti }
{------------------------------------------------------------}
  procedure isjungti (k, { si—stuvo numeris }
                      sek: integer; { kada jis buvo paleistas }
                      var imt: imtuvas);
  { ižjungia k-t…j si—stuva (atstato masyv… imt) }
    var sign: integer;
  begin
    sign := 1;
    while skl[k, sign] <> 0 do
      begin
        imt[sek + skl[k, sign]] := false;
        sign := sign + 1
      end;
  end; { ižjungti }
{------------------------------------------------------------}
  procedure jungimas (var kada: siustuv);
  { randa optimali… si—stuv— jungimo tvark… }
    var laikas, { kada pradeda veikti kiekvienas si—stuvas }
        ilg: siustuv; { si—stuv— pranežim— perdavimo ilgiai }
        k, i,
        pask, { laiko momentas, kada imtuv… pasiekia }
                       { paskutinis signalas optimaliame sprendinyje }
        pask_e: integer; { ir nagrin‚jamame sprendinyje }
        imt: imtuvas;  { kuriais momentais imtuv… pasiekia signalai }
        gerai: boolean;
        opt: siustuv;

    procedure delioti (k, pask_e: integer; laikas: siustuv;
                       var kada: siustuv; { optimali jungimo tvarka }
                       var pask: integer);
    { rekursinÓ proced×ra, d‚liojanti si—stuvus }
    { k - nagrinÓjamas si—stuvas }
    { pask_e - kada imtuv… pasiekia jau jungt— si—stuv— paskutinis signalas }
      var senas, sek: integer;
          gerai: boolean;
    begin
      if k > n     { jei visi si—stuvai jungti }
      then begin   { tai radome geresn sprendin }
                 kada := laikas;
                 pask := pask_e;
           end
      else begin
             sek := laikas[k-1] + 1;
             senas := pask_e;
             while sek + opt[k] < pask do { jei yra prasm‚ jungti }
               begin
                 { bandome jungti }
                 ijungti (k, sek, imt, gerai);
                 if gerai then
                   begin
                     laikas[k] := sek;
                     if pask_e < sek + ilg[k]
                        then pask_e := sek + ilg[k];
                     delioti (k+1, pask_e, laikas, kada, pask);
                     pask_e := senas;
                     isjungti (k, sek, imt);
                     if k = n then sek := pask;
                   end;
                sek := sek + 1;
               end;
           end;
    end; { d‚lioti }

    var j: integer;
  begin
    skleistine (skl);
    { randame kiekvieno pranežimo ilg }
    for k := 1 to n do
      ilg[k] := l[k] + (p[k]-1) * t[k];
    opt[n] := ilg[n];
    for i := n-1 downto 1 do
      { optimaliai sujungsime si—stuvus nuo i-tojo iki n-tojo }
      begin
        { imtuvo nepasiek‚ nei vienas signalas }
        for j := 1 to LAIK*MAX_N do
           imt[j] := false;
        { i-t…j si—stuv… jungiame nuliniu momentu }
        laikas[i] := 0;
        ijungti (i, 0, imt, gerai);
        pask_e := ilg[i];
        { randame teising…, ta‡iau neb–tinai optimal— sprendin }
        for k := i to n do
          begin
            if k = 1
               then kada[k] := 0
               else kada[k] := pask + 1;
            pask := kada[k] + ilg[k];
          end;
        delioti (i+1, pask_e, laikas, kada, pask);
        opt[i] :=  pask;
      end;
  end; { jungimas }

{------------------------------------------------------------ }
  var f: text;
      k: integer;
      kada: siustuv;
begin
  { skaitomi pradiniai duomenys }
  assign (f, 'RYSYS.DAT');
  reset (f);
  readln (f, n);
  for k := 1 to n do
    readln (f, t[k], l[k], p[k]);
  close (f);
  jungimas (kada);
  assign (f, 'RYSYS.REZ');
  rewrite (f);
  for k := 1 to n do
    writeln (f, kada[k]);
  close (f);
end.


