program astuoniasdesimt_dienu;
const maxtr = 200; { max traukini— (maržrut—) skai‡ius }
      maxm = 500;  { max miest— skai‡ius }
      maxst = 150;
      para = 60*24; { paros laikas minut‚mis }
type
  TStotis = record
    l : longint;  { atvykimo laikas. Ižvykimo laikas, jei pradin‚, minut‚mis }
    miest : word; { miestas }
  end;
  TTraukinys = array [0..maxst] of TStotis;
  TTraukiniai = array [1..maxtr] of ^TTraukinys;
  TStociuSk = array [1..maxtr] of integer;

  TBriauna = record
    tr, st : byte;  { koks taukinys ižvykta iž miesto TTraukinys[st].miest }
  end;
  TBriaunos = array [1..maxst*maxtr] of TBriauna; { visos Briaunos }

  THelp = array [1..maxm] of
      record nuo, iki : word; end;
{ --------------- Technin‚ briaun— paiežkos dalis (id‚ja) ----------------- }
{ Paprastai briaun— reikia iežkoti pagal ižvykimo stotŤ. Kad nereikt—
  per‘i–r‚ti viso briaun— masyvo, jis iž prad‘i— surikiuojamas pagal ižvykimo
  stotis ir Ť masyv… THelp suražoma pagalbin‚ informacija.
  Iž miesto i galima ižvykti traukiniais suražytais masyve TBriaunos intervale
  THelp[i].nuo iki THelp[i].iki.
  Taip gauname greit… reikaling— traukini— paiežk….
  Rikiavimui naudojamas QuickSort algoritmas.
}
  TMiestas = record
    buta,             { ar Ť žŤ miest… buvo pavykŠ patekti }
    nagr : boolean;   { ar žis miestas jau nagrin‚tas, t.y.,
                        ar buvo bandoma iž jo ižvykti }
    laikas : longint; { minimalus ‘inomas patekimo laikas Ť žŤ miest…
                        (minut‚mis) }
    is : word;        { iž kur buvo atvykta Ť žŤ miest… }
    tr : word;        { kuriuo traukiniu }
  end;
  TMiestai = array [1..maxm] of TMiestas;

var br : ^TBriaunos;
    tr : TTraukiniai;
    miest : TMiestai;
    m_cnt : integer;  { miest— skai‡ius }
    tr_cnt : integer;
    hl : THelp;
    m_pr : integer;
    l_cnt : word;
    st_sk : TStociuSk;

procedure skaityk_duomenis;
  var f : text; i, j, d : integer;
  a, b : longint;
begin
  assign (f, '80die.dat');
  reset (f);
  readln (f, m_cnt, m_pr, tr_cnt);
  l_cnt := 0;
  for i := 1 to tr_cnt do
    begin
      new (tr[i]);
      readln (f, tr[i]^[0].miest, a,b, d);
      st_sk[i] := d;
      tr[i]^[0].l := a*60+b;
      inc (l_cnt);
      br^[l_cnt].tr := i;
      br^[l_cnt].st := 0;
      for j := 1 to d do
        begin
          readln (f, tr[i]^[j].miest, a,b);
          tr[i]^[j].l := a*60+b+tr[i]^[j-1].l;
          if j<>d then
            begin
              inc (l_cnt);
              br^[l_cnt].tr := i;
              br^[l_cnt].st := j;
            end;
        end;
    end;
  close (f);
end;

procedure spausdink_atsakyma;
  var f : text; i, j : integer;
begin
  assign (f, '80die.rez');
  rewrite (f);
  if not miest[m_pr].buta then writeln (f, 'NEGALIMA') else
  begin
    writeln (f, miest[m_pr].laikas div para,' ',
                miest[m_pr].laikas mod para div 60,' ',
                miest[m_pr].laikas mod 60);
  end;
(* spausdinama pagalbin‚ inf. apie kelion‚s maržrut… *)
{-----------------------------------------------------------------------}
  if miest[m_pr].buta then { spausdiname keli… }
    begin
      i := m_pr;
      repeat
         writeln (f, miest[i].is, ' ',i, ' ', miest[i].tr, '    ',
                     miest[i].laikas div para,' ',
                     miest[i].laikas mod para div 60,' ',
                     miest[i].laikas mod 60);
         i := miest[i].is;
      until i=m_pr;
    end;
{-----------------------------------------------------------------------}
  close (f);
end;

procedure quicksort (var a : TBriaunos); { Rikiavimas }

procedure sort(l,r: integer);
var
  i,j,x: integer;
  y : TBriauna;
begin
  i:=l; j:=r; x:=tr[a[(l+r) DIV 2].tr]^[a[(l+r) DIV 2].st].miest;
  repeat
    while tr[a[i].tr]^[a[i].st].miest<x do i:=i+1;
    while x<tr[a[j].tr]^[a[j].st].miest do j:=j-1;
    if i<=j then
    begin
      y:=a[i]; a[i]:=a[j]; a[j]:=y;
      i:=i+1; j:=j-1;
    end;
  until i>j;
  if l<j then sort(l,j);
  if i<r then sort(i,r);
end;

begin {quicksort};
  sort(1,l_cnt);
end;

procedure paruosk_briaunas;
  var i, j, l : word;
begin
  quicksort (br^); { surikiuojam }
  fillchar (hl, sizeof(hl), 0);
  { suražome informacij… apie intervalus }
  hl[ tr[br^[1].tr]^[br^[1].st].miest ].nuo := 1;
  hl[ tr[br^[l_cnt].tr]^[br^[l_cnt].st].miest ].iki := l_cnt;
  for i := 2 to l_cnt do
    if tr[br^[i].tr]^[br^[i].st].miest <> tr[br^[i-1].tr]^[br^[i-1].st].miest then
      begin
        hl[ tr[br^[i].tr]^[br^[i].st].miest ] .nuo := i;
        hl[ tr[br^[i-1].tr]^[br^[i-1].st].miest].iki := i-1;
      end;
end;

procedure dijkstra;
  var i, j : integer;
procedure eik_is (is : integer); { nagrin‚jamas is miestas }
  var i,d, t, s : integer; l, la, li, laukti : longint;
begin
  miest[is].nagr := true;
  if hl[is].nuo = 0 then exit;
  if is = m_pr then l := 0 else l := miest[is].laikas;
  for i := hl[ is].nuo to hl[is].iki do { renkam‚s traukinŤ }
    for d := 1 to st_sk[br^[i].tr]-br^[i].st do  { renkam‚s stotŤ }
    begin
      { t - traukinys, s- stotel‚s nr.,li - laikas ižvykimo,
        la - laikas atvykimo }
      t := br^[i].tr; s := br^[i].st;
      li := tr[t]^[s].l mod para;
      laukti := li-miest[is].laikas mod para;
      if (laukti <5) and (is<>m_pr) then laukti := laukti+para;
      { nesp‚jame Ť žŤ traukinŤ, tenka laukti par… }
      la := (tr[t]^[s+d].l-tr[t]^[s].l)+miest[is].laikas+laukti;
      if not miest [tr[t]^[s+d].miest].buta or
         (miest [tr[t]^[s+d].miest].laikas > la) then
         begin
            miest [tr[t]^[s+d].miest].laikas := la;
            miest [tr[t]^[s+d].miest].buta := true;
            miest [tr[t]^[s+d].miest].is := is;
            miest [tr[t]^[s+d].miest].tr := t;
         end;
    end;
end;

function rask_min:integer;  { randa miest…, kurŤ reikt— nagrin‚ti }
  var min,i : integer;
begin
  min := 0;
  for i := 1 to m_cnt do
    if not miest[i].nagr and miest[i].buta then
      if (min=0) or (miest[min].laikas>miest[i].laikas) then min := i;
  rask_min := min;
end;

begin
  for i := 1 to m_cnt do
     begin miest[i].buta := false; miest[i].nagr := false; end;
  miest[m_pr].buta := false;
  eik_is (m_pr);
  i := rask_min;
  while i<>0 do
    begin
      eik_is (i);
      i := rask_min ;
    end;
end;

begin
  new (br);
  skaityk_duomenis;
  paruosk_briaunas;
  dijkstra;
  spausdink_atsakyma;
  dispose (br);
end.