{$M 65520,0,655360}
program siustuvai_ir_imtuvas;
  { 129 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 }

  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 rikiuoti (ilg: siustuv; var tvarka: siustuv);
  { rikiuoja si—stuvus pranežim— perdavimo laiko ma‘‚jimo tvarka }
  { rikiuojama burbuliuko metodu }
    var i, tarp: integer;
  begin
      i := 1;
      while i < n do
        if ilg[tvarka[i]] >= ilg[tvarka[i+1]]
           then i := i + 1
           else begin  { sukei‡iame i-t…jŤ ir i+1-m…jŤ element… }
                  tarp := tvarka[i];
                  tvarka[i] := tvarka[i + 1];
                  tvarka[i + 1] := tarp;
                  if i > 1 then i := i - 1
                           else i := i + 1;
                end
  end; { rikiuoti }

  procedure jungimas (var kada: siustuv);
  { randa optimali… si—stuv— Ťjungimo tvark… }
    var skl: lentele;
        laikas, { kada pradeda veikti kiekvienas si—stuvas }
        tvarka, { kokia tvarka bandysime jungti si—stuvus }
        ilg: siustuv; { si—stuv— pranežim— perdavimo ilgiai }
        i, k, pirmas, num, sek,
        pask, { laiko momentas, kada imtuv… pasiekia }
                       { paskutinis signalas optimaliame sprendinyje }
        pask_e: integer; { ir nagrin‚jamame sprendinyje }
        imt: imtuvas;  { kuriais momentais imtuv… pasiekia signalai }

    procedure galima (k, sek: integer;
                      var imt: imtuvas; var gerai: boolean);
    { ar galima si—stuv… k paleisti laiko momentu sek ? }
    { jei galima, tai pakeiŃiamas masyvas imt }
     var sign, i: integer;
    begin
      sign := 1;
      gerai := true;
      while (skl[k, sign] <> 0) and gerai 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;
                    gerai := false
                 end
             else imt[sek + skl[k, sign]] := true;
          sign := sign + 1
        end;
    end; { galima }

    procedure atgal (k, { si—stuvo numeris }
                     sek: integer; { kada jis buvo paleistas }
                     var imt: imtuvas);
    { atstato masyv… imt, kai grŤŘtama per ‘ingsnŤ atgal }
      var sign: integer;
    begin
      sign := 1;
      while skl[k, sign] <> 0 do
        begin
          imt[sek + skl[k, sign]] := false;
          sign := sign + 1
        end;
    end; { atgal }

    procedure delioti (nr, pask_e: integer; laikas: siustuv;
                       var kada: siustuv; var pask: integer);
    { rekursinÓ proced×ra, d‚liojanti si—stuvus }
    { nr - nagrinÓjamas si—stuvas }
    { pask-e - kada imtuv… pasiekia Ťjungt— si—stuv— paskutinis signalas }
      var k, senas, sek: integer;
          gerai: boolean;
    begin
      if nr > n { jei visi si—stuvai Ťjungti }
      then begin      { tai radome geresnŤ sprendinŤ }
             if pask_e < pask then
               begin
                 kada := laikas;
                 pask := pask_e;
               end;
           end
      else begin
             k := tvarka[nr]; { jungsime si—stuv… k }
             sek := 0; { bandysime jungti nulinŠ sekundŠ }
             while sek + ilg[k] < pask do
               begin
                 galima (k, sek, imt, gerai);
                 { jei si—stuv… galima Ťjungti sekundŠ sek }
                 if gerai then
                   begin
                     senas := pask_e;
                     if pask_e < sek + ilg[k]
                        then pask_e := sek + ilg[k];
                     laikas[k] := sek;
                     delioti (nr+1, pask_e, laikas, kada, pask);
                     pask_e := senas;
                     atgal (k, sek, imt);
                     if nr = n then sek := pask;
                   end;
                 sek := sek + 1;
               end;
           end;
    end; { d‚lioti }

  begin
    skleistine (skl);
    { randame kiekvieno pranežimo ilgŤ; bei teising…, ta‡iau neb–tinai }
    { optimal— sprendinŤ }
    for k := 1 to n do
      begin
        tvarka[k] := k;
        ilg[k] := l[k] + (p[k]-1)*t[k];
        if k = 1
           then kada[k] := 0
           else kada[k] := pask + 1;
        pask :=  kada[k] + ilg[k];
      end;
    { si—stuvus surikiuosime pranežim— perdavimo laiko ma‘‚jimo tvarka }
    { tokia tvarka juos v‚liau bandysime jungti }
    rikiuoti (ilg, tvarka);
    { parenkame laik…, kada Ťjungsime ilgiausiai dirbantŤ si—stuv… }
    pirmas := 0; { ilgiausiai dirbantŤ Ťjungiame nuliniu momentu }
    num := tvarka[1];
    while (pirmas + ilg[num]) < pask do { jei dar verta skai‡iuoti }
      begin
        for k := 1 to n do  { visi si—stuvai ižjungti }
          laikas[k] := 0;
        for i := 1 to pask do { imtuvo nepasiek‚ nei vienas signalas }
          imt[i] := false;
        { Ťjungiame ilgiausiai dirbantŤ imtuv… }
        laikas[num] := pirmas;
        sek := laikas[num] + l[num];
        for i := 1 to p[num] do
          begin
            imt[sek] := true;
            sek := sek + t[num]
          end;
        pask_e := pirmas + ilg[num];
        delioti (2, pask_e, laikas, kada, pask);
        pirmas := pirmas + 1; { bandysime jungti sekunde v‚liau }
      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.