Program Midi;

type radek = record
              cas:word;     {0..2^16-1}
              stav:boolean; {ON=TRUE, OFF=False}
              ton:word;
             end;
var F,F2                    :text;       {vstup/vystup soubor}
    dalsi                   :radek;      {pomocna promenna}
    akt_cas,pr_cas          :array [1..255] of radek;
                                       {2 tabulky dvou cas.jednotek po sobe}
    pocet_pr_cas,pocet_akt_cas:byte; {pocty prvku v predchozich tabulkach}

    zapnuty         :array[1..255] of record        {tabulka zapnutych tonu}
                                      ton:byte;
                                      vypustit:integer;
                                      end;
    poc_zap:byte;       {pocet zapnutych tonu, tj.pocet prvku v "zapnuty"}
    bool                    :boolean; {pomocne prom.}
    a,b:byte;

Procedure GetRadek( var R:radek); {nacte 1 midi radek ze souboru}
var s:String[4];
    a,kontrola: Integer ;
begin
  read(F,r.cas); if eof(F) then
    begin
      r.ton:=0;
      exit;
    end;
  read(F,s);
  read(F,r.ton);
  if s[3]='F' then r.stav:= false
   else r.stav:=true;
end;

procedure putRadek(r:radek);      {vlozi 1 midi radek do souboru}
begin
  write(f2,r.cas);
  write(f2,' ');
  if r.stav then write(f2,'ON ')
    else write(f2,'OFF ');
  writeln(f2,r.ton);
end;

function zapnuto(ton:byte):boolean; {je dany ton uz zapnut ?}
var a:byte;
begin
  a:=1;
  zapnuto:=false;
  while poc_zap >=a do
  begin
    if zapnuty[a].ton = ton then
    begin
      zapnuto:=true;
      exit;
    end;
    inc(a);
  end;
end;

Procedure vypniTon(ton:byte); {vypni ton,tj.odstran z tabulky zapnuty}
var a:byte;
begin
  for a:=1 to poc_zap do
  if zapnuty[a].ton =ton then
  begin
    for b:=a+1 to poc_zap do
    begin
      zapnuty[b-1].ton:=zapnuty[b].ton;
      zapnuty[b-1].vypustit:=zapnuty[b].vypustit;
    end;
    dec(poc_zap);
    exit;
  end;
end;


function pozadVyp(ton:byte):byte; {vraci poradi znejiciho tonu}
var a:byte;                                     {v tabulce, pokud ton nezni }
begin                                           {vraci 0 }
  a:=1;
  while poc_zap >=a do
  begin
    if (zapnuty[a].ton=ton) then
    begin
      pozadVyp:=a;
      exit;
    end;
    inc(a);
  end;
  pozadVyp:=0;
end;

procedure nacti_jednotku; {nacte do akt_cas vechny radky s jednim
casem}
begin                     {posledni radek s jinym casem ulozi do "dalsi"}
    for a:= 1 to 254 do
    begin
      getRadek(akt_cas[a+1]);
      if akt_cas[a+1].ton =0 then    {konec radku ve vstup souboru}
      begin
        dalsi.ton:=0;
        break;
      end;
      if (akt_cas[a+1].cas > akt_cas[a].cas) then
      begin
        dalsi:=akt_cas[a+1];
        break;
      end;
    end;
    pocet_akt_cas:=a;
end;

begin
  assign(F,{paramStr(1)}'in.txt');  {otevreni vstupu}
  reset(F);
  assign(F2,{paramStr(2)}'out.txt'); {otevreni vystupu}
  rewrite(F2);
  getRadek(akt_cas[1]);
  nacti_jednotku;
  pocet_pr_cas:=0;
  repeat     {vlastni cyklus pro zapracovani a upravu dat}
    a:=1;    {je-li v promn. a hodnota x, potom program prave zpracovava }
    repeat                   {x-ty radek v poli cas2 }
      if akt_cas[a].stav then                        {***1}
      begin
        if zapnuto (akt_cas[a].ton) then             {***1b}
        begin
          bool:=false;
          if (akt_cas[1].cas - pr_cas[1].cas =1) then
            for b:=1 to pocet_pr_cas do
              if pr_cas[b].stav and (pr_cas[b].ton=akt_cas[a].ton) then
                bool:=true;
          if bool then                            {***1ba}
          begin
            akt_cas[a].ton:=0;
            inc(zapnuty[pozadVyp(akt_Cas[a].ton)].vypustit);
          end
          else
          begin                                    {***1bB}
            inc(pocet_pr_cas);
            pr_cas[pocet_pr_cas].ton:=akt_cas[a].ton;
            pr_cas[pocet_pr_cas].stav:=false;
            pr_cas[pocet_pr_cas].cas:=akt_cas[a].cas -1;
            inc(zapnuty[pozadVyp(akt_Cas[a].ton)].vypustit);
          end;
        end
        else
        begin                                       {***1a}
          inc(poc_zap);
          zapnuty[poc_zap].ton:=akt_cas[a].ton;
          zapnuty[poc_zap].vypustit:=0;
        end;
      end
      else
      begin                                         {***2}
        b:=pozadVyp(akt_cas[a].ton);
        if zapnuty[b].vypustit >0 then              {***2b}
        begin
          dec(zapnuty[b].vypustit);
          akt_cas[a].ton:=0;
        end
        else
        begin                                       {***2a}
          bool:=false;
          if a<pocet_akt_cas then
          for b:=a+1 to pocet_akt_cas do
           if akt_cas[b].stav and (akt_cas[a].ton = akt_cas[b].ton) then
           begin
            inc(pocet_akt_cas);
            akt_cas[pocet_akt_cas].ton:=akt_cas[a].ton;
            akt_cas[pocet_akt_cas].cas:=akt_cas[a].cas;
            akt_cas[pocet_akt_cas].stav:=false;
            akt_cas[a].ton:=0;
            bool:=true;
            break;
           end;
          if not bool then vypniTon(akt_cas[a].ton);   {***2ab}
        end;
      end;
      inc(a);                                 {dalsi radek v akt_Cas}
    until a> pocet_akt_cas;

    for a:=1 to pocet_pr_cas do putRAdek(pr_cas[a]); {pr_cas->vystup.soub}
    if dalsi.ton = 0 then
    begin
      if pocet_akt_cas <>0 then for a:=1 to pocet_akt_cas do
        if akt_cas[a].ton>0 then putRAdek(akt_cas[a]);
        {musi se take nakonec ulozit i akt_cas}
      close(f);
      close(F2);
      halt(0);
    end;

    pocet_pr_cas:=0;                 {cas2 ->cas1}
    for a:= 1 to pocet_akt_cas do
    if akt_cas[a].ton >0 then
    begin
      inc(pocet_pr_cas);
      pr_cas[pocet_pr_cas]:=akt_cas[a];
    end;

    akt_cas[1]:=dalsi;   {nova casova jednotka ->cas}
    nacti_jednotku;
  until false;
end.