{
TASK:TRAUK
LANG:PASCAL
}

program traukiniai;


  const PR = 'trauk.dat';
        RZ = 'trauk.rez';
        MAX_S = 10000; { maksimalus stočių skaičius }
        MAX_TR = 1000;  { maksimalus traukinių skaičius }
        MAX = MAX_TR*100; { maksimalus reisų tarp dviejų stočių skaičius }
        MAX_T = 12*60; { maksimalus kelionei leidžiamas minučių skaičius }

  type  marsrutas = record
                      iss, ats, { atvykimo, išvykimo stotis }
                      ism, atm: longint; { bei laikas }
                    end;

  type sarasas = array [1..MAX] of marsrutas;
       lentele = array [0..MAX_T, 1..MAX_S] of integer;
       log_lentele = array[-1..MAX_T] of boolean;

  { žemiau aprašyti globalieji kintamieji }
  var m: sarasas; { maršrutų sąrašas }
      R: longint;     { ir jo ilgis }
      W: lentele;  { svorių lentelė }

  procedure pasalinti (var m: sarasas; var R: longint);
    { pašalina netinkamus reisus }
    var i: longint;
  begin
    i := 1;
    while i <= R do
        if (m[i].ism > 12*60) or (m[i].atm > 12*60)
           then { reisas per vėlai atvyksta }
             begin
               m[i] := m[R];
               R := R - 1;
             end
          else i := i + 1
 end; { pašalinti }

 procedure Qsort  (var M: sarasas; k1, k2: longint);
   { surikiuoja reisus išvykimo vėlėjimo tvarka }
     var i, j: longint;
         a, y: marsrutas;
  begin
    i := k1; j := k2;
    y := m[(i+j) div 2];
    repeat
      while y.ism > M[i].ism do i := i + 1;
      While y.ism < M[j].ism do j := j - 1;
      if i <= j
         then begin
                a := M[i]; M[i] := M[j]; M[j] := a;
                i := i + 1; j := j - 1;
              end;
    until i > j;
    if k1 < j then Qsort (M, k1, j);
    if i < k2 then Qsort (M, i, k2);
  end; { Qsort }


  procedure reisas (t: integer; var ind, nr: longint; var yra: boolean);
    { randa tolesnį reisą, kuris išvyksta laiku t }
  begin
    yra := m[ind].ism = t;
    if yra
       then begin
              nr := ind;
              ind := ind + 1; { šis reisas jau sunaudotas }
            end;
  end; { reisas }

 procedure vaziuoti (S: integer; var min, sto: integer; var galima: boolean);
   var ind, nr: longint;
       t, st, is, kur, kada, tt: integer;
       pasiekta: log_lentele;
       yra: boolean;
 begin
   pasalinti (m, R); { pašalina netinkamus reisus }
   Qsort (m, 1, R);
   for t := 0 to max_t do
     begin
       W[t, 1] := 1; { pirma stotis pasiekiama iš karto }
       for st := 2 to S do
           W[t, st] := maxint;
     end;
   for t := -1 to max_t do
     pasiekta[t] := false;
   t := -1;
   ind := 1; { pradėsime nup pirmojo reiso }
   while (t < max_t) and not pasiekta[t] do
     begin
       t := t + 1;
       if ind <= R
          then reisas (t, ind, nr, yra)
          else yra := false;
       while yra do
         begin { registruojame išvažiuojančius traukinius }
           if (W[t, m[nr].iss] < maxint) { jei iš šios stoties galima išvykti }
              then begin { užpildome išvykimą }
                      is := m[nr].iss;
                      kur := m[nr].ats;
                      kada := m[nr].atm;
                      for tt := kada to max_t do
                        if W[t, is] + 1 < W[tt, kur]
                           then W[tt, kur] := W[tt, is] + 1;
                      if kur = S
                         then pasiekta[kada] := true;
                    end;
            if ind <= R
               then reisas (t, ind, nr, yra)
               else yra := false;
         end; { while nr > 0 }
     end;
    { gaunamas rezultatas }
    galima := pasiekta[t];
    min := t;
    sto := W[t, S];
 end; { važiuoti }

 procedure skaityti (var R: longint; var S: integer; { reisų ir stoči skaičius }
                      var m: sarasas);
    var f: text;
        i, j, TR, K, atv, atm, isv, ism: longint;
  begin
    assign (f, PR);
    reset (f);
    readln (f, TR, S);
    r := 1;
    for i := 1 to TR do
      begin
        read (f, K);
        read (f, m[r].iss, atv, atm, isv, ism);
        m[r].ism := isv*60+ism;
        for j := 1 to K-1 do
          begin
            read (f, m[r].ats, atv, atm, isv, ism);
            m[r].atm := atv*60+atm;
            m[r+1].ism := isv*60+ism;
            m[r+1].iss := m[r].ats;
            r := r + 1;
          end;
       end;
    r := r - 1;
    close (f);
  end; { skaityti }

  procedure spausdinti (min, sto: integer; galima: boolean);
    var f: text;
  begin
    assign (f, RZ);
    rewrite (f);
    if galima
       then writeln (f, 'TAIP')
       else writeln (f, 'NE');
    if galima
       then writeln (f, min, ' ', sto);
    close (f);
  end; { spausdinti }

  var S, min, sto: integer;
      galima: boolean;
begin
  skaityti (R, S, m);
  vaziuoti (S, min, sto, galima);
  spausdinti (min, sto, galima);
end.