program masininiu_kodu_interpretatorius;
  { Jaunesni—j— grup‚s u‘davinio sprendimas }
  const PR1 = 'INT.DAT';
        PR2 = 'PROG.EXC';
        MAX_N = 8000; { maksimali N reikžm‚ }
        SK = 9; { kiek skaitmen— laikoma vienoje atminties laukelio dalyje }
        DG = 1000000000;

  type laukelis = array [1..2] of longint;
       atmintis = array [0..MAX_N] of laukelis;


  { ‘emiau apražyti globalieji kintamieji }
  var a: atmintis;
      k,          { laukelio dyd‘io ribojimas }
      N,          { atminties laukeli— skai‡ius }
      R: longint; { registras }

  procedure suma (var x: laukelis; y: laukelis);
    { a[x] := a[x] + a[y] }
  begin
    if x[2] >= DG - y[2]
       then begin
              x[1] := x[1] + 1;
              x[2] := x[2] - DG;
              x[2] := x[2] + y[2];
            end
       else x[2] := x[2] + y[2];
    x[1] := x[1] + y[1];
  end; { suma }

  procedure skirt (var x: laukelis; y: laukelis);
    { a[x] := a[x] - a[y] }
  begin
    if x[2] < y[2]
       then begin
              x[1] := x[1] - 1;
              x[2] := x[2] - y[2];
              x[2] := x[2] + DG;
            end
       else x[2] := x[2] - y[2];
   x[1] := x[1] - y[1];
  end; { skirt }

  procedure perskaityti (var x: laukelis);
    var s: string;
        reiksme: longint;
        kodas: integer;
        pirmas, kiek: longint;
  begin
    readln (s);
    kiek := length (s);
    pirmas := kiek - SK;
    if pirmas < 0
       then pirmas := 0;
    val(copy(s, 1, pirmas), reiksme, kodas);
    if kodas <> 0
       then x[1] := 0
       else x[1] := reiksme;
    delete (s, 1, pirmas);
    val(s, reiksme, kodas);
    x[2] := reiksme;
  end; { perskaityti }

  procedure rasyti (var x: laukelis);
    var nuliai: string;
        kiek, laik, i: longint;
  begin
    { ražoma pirma dalis }
    if x[1] <> 0
       then write (x[1]);
    { ražoma antra dalis }
    nuliai := '';
    if x[1] <> 0
       then begin
              { rasime antrosios dalies skai‡i— }
              laik := x[2]; kiek := 0;
              while laik > 0 do
                begin
                  laik := laik div 10;
                  kiek := kiek + 1
                end;
               for i := 1 to SK - kiek do
                 nuliai := nuliai + '0';
            end;
    write (nuliai);
    if x[2] <> 0 then writeln (x[2]);
  end; { ražyti }

  function daugiau (x, y: laukelis): boolean;
   { daugiau := a[x] > a[y] }
  begin
    daugiau := (x[1] > y[1]) or
               (x[1] = y[1]) and (x[2] > y[2]);
  end; { daugiau }

  function lygu1 (x, y: laukelis): boolean;
   { lygu1 := a[x] = a[y] }
  begin
    lygu1 := (x[1] = y[1]) and (x[2] = y[2]);
  end; { lygu1 }

  function lygu2 (x: laukelis; y: longint): boolean;
   { lygu2 := a[x] = y }
   var l: laukelis;
  begin
    l[1] := y div DG;
    l[2] := y mod DG;
    lygu2 := lygu1 (x, l);
  end; { lygu2 }

  procedure priskirti (var x: laukelis; y: longint);
    { a[x] := y }
  begin
    x[1] := y div DG;
    x[2] := y mod DG;
  end; { priskirti }

  procedure vykdyti_komanda (kodas, I: longint; J: laukelis; var R: longint);
  begin
    if kodas in [6, 7, 13]
       then R := R + 2
       else R := R + 3;
    case kodas of
      0: a[I] := J;
      1: a[I] := a[J[2]];
      2: suma (a[I], J);
      3: suma (a[I], a[J[2]]);
      4: skirt (a[I], J);
      5: skirt (a[I], a[J[2]]);
      6: perskaityti (a[I]);
      7: rasyti (a[I]);
      8: if daugiau (a[I], a[J[2]])
         then priskirti (a[I], 1) else priskirti (a[I], 0);
      9: if lygu1 (a[I], a[J[2]])
            then priskirti (a[I], 1) else priskirti (a[I], 0);
      10: if daugiau (a[J[2]], a[I])
            then priskirti (a[I], 1) else priskirti (a[I], 0);
      11: if lygu2 (a[J[2]], 0) then R := I;
      12: if not lygu2 (a[J[2]], 0) then R := I;
      13: R := I;
    end;
  end; { vykdyti_komand… }

  procedure interpretuoti;
    var pabaiga: boolean;
        kodas, I: longint;
        J: laukelis;
  begin
    pabaiga := false;
    repeat
      { imama eilin‚ komanda }
      kodas := a[R, 2];
      if kodas = 14
         then pabaiga := true
      else begin
             I := a[R+1, 2];
             if not (kodas in [6, 7, 13])
                then J := a[R+2];
              vykdyti_komanda (kodas, I, J, R);
           end;
    until pabaiga;
  end; { interpretuoti }

  procedure skaityti;
    { var k, N, R: longint; var a: atmintis }
    var f: text;
        i, M, reiksme: longint;
        pirmas, kiek, kodas: integer;
        s: string;
  begin
    { perskaitoma pirmoji byla }
    assign (f, PR1);
    reset (f);
    readln (f, N, k);
    close (f);
    { perskaitoma antroji byla }
    assign (f, PR2);
    reset (f);
    readln (f, R, M);
    for i := 0 to M-1 do
      begin
        readln (f, s);
        kiek := length (s);
        pirmas := kiek - SK;
        if pirmas < 0
           then pirmas := 0;
        val(copy(s, 1, pirmas), reiksme, kodas);
        if kodas <> 0
           then a[i, 1] := 0
           else a[i, 1] := reiksme;
        delete (s, 1, pirmas);
        val(s, reiksme, kodas);
        a[i, 2] := reiksme;
      end;
    close (f);
  end; { skaityti }

begin
  skaityti;
  interpretuoti;
end.