program sachmatai;
  { 113 u‘davinys }

  { ******************** duomen— tipai ******************************* }

  type koordinates = record
                       x, y: integer;
                     end;
       spalva = (juoda, balta);
       tipas = (karalius, valdove, bokstas, rikis, zirgas, pestininkas);
       figura = record
                  k: koordinates; { fig–ros koordinat‚s }
                  s: spalva;     { spalva }
                  t: tipas        { ir tipas }
                end;

       fig_sar = array [0..32] of figura;  { fig–r— s…ražas }
           { fig[0] - kuria fig–ra ir kur einama žacho atveju }
       lenta = array [1..8, 1..8] of integer;

  { ********************** globalieji kintamieji ********************** }

    var n: integer;   { fig–r— skai‡ius }
        fig: fig_sar; { fig–r— s…ražas }
        len: lenta;   { žachmat— lenta - kokiame langelyje kokia fig–ra }

  { ********************* pradini— duomen— Ťvedimas ******************* }

  procedure ivesti;
  { duomen— Ťvedimo proced–ra }
  { vartoja globalius kintamuosius n, fig, len }
    var f: text;
        i, j: integer;
        st: string;
  begin
    assign (f, 'SACHM.DAT');
    reset (f);
    readln (f, n);
    for i := 1 to 8 do       { inicializuojama tuž‡ia lenta }
      for j := 1 to 8 do
        len[i, j] := 0;
    for i := 1 to n do
       with fig[i] do        { Ťvedama informacija apie fig–r… }
         begin
           readln (f, st);
           if st[1] = 'b'
             then s := balta
             else s := juoda;
           case st[2] of
             'P': t := pestininkas;
             'R': t := rikis;
             'B': t := bokstas;
             'V': t := valdove;
             'Z': t := zirgas;
             'K': t := karalius
          end;
          k.x := ord(st[3]) - ord('0');
          k.y := ord(st[4]) - ord('0');
          len[k.x, k.y] := i
       end;
    close (f);
  end; { Ťvesti }

  { ******************************************************************** }

  function ribose (x, y: integer): boolean;
  { ar kordinat‚s neižeina iž lentos rib— }
  begin
    ribose := (x > 0) and (x < 9) and (y > 0) and (y < 9)
  end; { ribose }

  { ********************* ar karalius žachuojamas ********************** }

  function yra_fig (x, y: integer; tp: tipas; sp: spalva): boolean;
  { ar pozicijoje (x, y) yra "tp" tipo ir "sp" spalvos fig–ra }
  begin
    if len[x, y] = 0
       then yra_fig := false
       else yra_fig := (fig[len[x, y]].t = tp) and (fig[len [x, y]].s = sp)
  end; { yra_fig }

  function sach_krypt (kor: koordinates; dx, dy: integer): boolean;
  { tikrina, ar fig–ra, galinti jud‚ti nurodyta kryptimi žachuoja karali—; }
  { jos jud‚jimo kryptŤ nusako dx ir dy - koordina‡i— poky‡iai }
  begin
    kor.x := kor.x + dx;
    kor.y := kor.y + dy;
    while ribose (kor.x, kor.y) and (len[kor.x, kor.y] = 0) do
      begin                   { einame, kol sutinkame fig–r… ar }
        kor.x := kor.x + dx;  { prieiname lentos kražt… }
        kor.y := kor.y + dy
      end;
    if ribose (kor.x, kor.y)
       then if yra_fig (kor.x, kor.y, karalius, juoda)
               then sach_krypt := true
               else sach_krypt := false { sutikome ne karali— }
       else sach_krypt := false { iž‚jome iž rib— nesutikŠ fig–ros }
  end;  { sach_krypt }

  function sach_pest (kor: koordinates): boolean;
  begin
    sach_pest := ribose (kor.x - 1, kor.y + 1) and
                 yra_fig (kor.x - 1, kor.y + 1, karalius, juoda) or
                 ribose (kor.x + 1, kor.y + 1) and
                 yra_fig (kor.x + 1, kor.y + 1, karalius, juoda)
  end; { sach_pest }

  function sach_rikis (kor: koordinates): boolean;
  begin
    sach_rikis := sach_krypt (kor, -1, -1) or sach_krypt (kor,  1, -1) or
                  sach_krypt (kor, -1,  1) or sach_krypt (kor,  1,  1)
  end; { sach_rikis }

  function sach_bokstas (kor: koordinates): boolean;
  begin
    sach_bokstas := sach_krypt (kor, 0, -1) or sach_krypt (kor,  0,  1) or
                    sach_krypt (kor, -1,  0) or sach_krypt (kor,  1,  0)
  end; { sach_bokstas }

  function sach_valdove (kor : koordinates): boolean;
  begin
    sach_valdove := sach_rikis (kor) or sach_bokstas (kor)
  end;  { sach_valdove }

  function sach_zirgas (kor: koordinates): boolean;
    var i, j: integer;
        sach: boolean;
  begin
    sach := false;
    for i := -2 to 2 do
       for j := -2 to 2 do
          if (abs(i) + abs(j) = 3) and ribose (kor.x + i, kor.y + j) and
             yra_fig (kor.x + i, kor.y + j, karalius, juoda)
             then sach := true;
    sach_zirgas := sach
  end; { sach_zirgas }

  function sachas: boolean;
  { tikrina, ar juod—j— karalius žachuojamas }
  { n, fig, len - globalieji kintamieji }
    var i: integer;
        sach: boolean;
  begin
    sach := false;
    i := 1;
    while (i <= n) and not sach do
      begin
        with fig[i] do    { tikrina, ar nežachuoja kuri nors fig–ra }
          if s = balta
             then case t of
                    pestininkas: sach := sach_pest (k);
                    zirgas     : sach := sach_zirgas (k);
                    rikis      : sach := sach_rikis (k);
                    bokstas    : sach := sach_bokstas (k);
                    valdove    : sach := sach_valdove (k);
                end;
        i := i + 1
      end;
    sachas := sach
  end; { sachas }

  { ************************* tikrinama, ar matas ********************* }

  function yra (x, y: integer; sp: spalva): boolean;
  { ar pozicijoje (x, y) yra bet kokia "sp" spalvos fig–ra }
  begin
    if len[x, y] = 0
       then yra := false
       else yra := fig[len [x, y]].s = sp
  end; { yra }

  function pasiseka (f, x, y: integer): boolean;
  { ar pasiseks ižvengti mato, pa‚jus fig–ra f Ť langelŤ (x, y) }
    var buv_f: integer;
        buv_k: koordinates;
        nukirsta: figura;
  begin
    buv_f := len[x, y]; { isimename, kas langelyje, Ť kurŤ norim eiti }
    if (buv_f = 0) or (fig[buv_f].s = balta) { jei langelyje ne savos }
    then with fig[f] do                      { (juodos) spalvos fig–ra }
           begin
             buv_k := k;         { Ťsimename buvusias koordinates }
             len[k.x, k.y] := 0; { atliekame ‚jim… }
             k.x := x; k.y := y;
             len[x, y] := f;
             if buv_f <> 0       { jei reikia, nukertame fig–r… }
                then begin
                       nukirsta := fig[buv_f];
                       fig[buv_f] := fig[n];
                       n := n - 1
                     end;
             if not sachas
                then begin { žacho ižvengta }
                       pasiseka := true;
                       fig[0] := fig[f];
                     end
                else begin { gr…‘iname atgal fig–ras }
                       k := buv_k;  { atstatome juod… fig–r… }
                       len[k.x, k.y] := f;
                       len[x, y] := buv_f;  { atstatome langelio turinŤ }
                       if buv_f <> 0        { jei buvo nukirsta juoda }
                          then  begin       { fig–ra, tai j… atstatome }
                                  n := n + 1;
                                  fig[n] := fig[buv_f];
                                  fig[buv_f] := nukirsta
                                end;
                       pasiseka := false
                     end
           end
    else pasiseka := false
  end; { pasiseka }

  function eik_krypt (f, dx, dy: integer): boolean;
    var saugu: boolean;
        kor: koordinates;
  begin
    saugu := false;
    kor.x := fig[f].k.x + dx;
    kor.y := fig[f].k.y + dy;
    while ribose (kor.x, kor.y) and (len[kor.x, kor.y] = 0) and not saugu do
      begin
        saugu := pasiseka (f, kor.x, kor.y);
        kor.x := kor.x + dx;
        kor.y := kor.y + dy
      end;
    if ribose (kor.x, kor.y)  and not saugu { jei sutikome fig–r… }
       then saugu := pasiseka (f, kor.x, kor.y);
    eik_krypt := saugu
  end; { eik_krypt }


  function ej_rikis (f: integer): boolean;
  begin
    ej_rikis := eik_krypt (f, -1, -1) or eik_krypt (f,  1, -1) or
                eik_krypt (f, -1,  1) or eik_krypt (f,  1,  1)
  end;

  function ej_bokstas (f: integer): boolean;
  begin
    ej_bokstas := eik_krypt (f,  0, -1) or eik_krypt (f,  0,  1) or
                  eik_krypt (f, -1,  0) or eik_krypt (f,  1,  0)
  end;

  function ej_valdove (f: integer): boolean;
  begin
    ej_valdove := ej_rikis (f) or ej_bokstas (f)
  end; { ej_valdove }

  function ej_zirgas (f: integer): boolean;
    var i, j: integer;
        kor: koordinates;
        saugu: boolean;
  begin
     kor := fig[f].k; { fig–ros koordinat‚s }
     saugu := false;
     for i := -2 to 2 do
        for j := -2 to 2 do
           if not saugu and (abs(i) + abs(j) = 3) and
              ribose (kor.x+i, kor.y+j) and pasiseka (f, kor.x+i, kor.y+j)
              then saugu := true;
     ej_zirgas := saugu
  end; { ej_zirgas }

  function ej_karalius (f: integer): boolean;
    var i, j: integer;
        kor: koordinates;
        saugu: boolean;
  begin
    kor := fig[f].k;
    saugu := false;
    for i := -1 to 1 do
       for j := -1 to 1 do
          if not saugu and (abs(i) + abs(j) <> 0) and
             ribose (kor.x+i, kor.y+j)
             then saugu := pasiseka (f, kor.x+i, kor.y+j);
    ej_karalius := saugu
  end; { ej_karalius }

  function ej_pest (f: integer): boolean;
    var kor: koordinates;
  begin
    kor := fig[f].k;
    ej_pest :=
      ribose (kor.x - 1, kor.y - 1) and   { kertama Ť dežinŠ }
      yra (kor.x - 1, kor.y - 1, balta) and pasiseka (f, kor.x - 1, kor.y - 1)
      or
      ribose (kor.x + 1, kor.y - 1) and   { kertama Ť kairŠ }
      yra (kor.x + 1, kor.y - 1, balta) and pasiseka (f, kor.x + 1, kor.y - 1)
      or
      ribose (kor.x, kor.y - 1) and (len [kor.x, kor.y - 1] = 0)
      and pasiseka (f, kor.x, kor.y - 1) { einama pirmyn per vien… langelŤ }
      or
      (kor.y = 7) and (len [kor.x, 5] = 0) and (len [kor.x, 6] = 0)
      and pasiseka (f, kor.x, 5)  { einama pirmyn per du langelius }
  end; { ej_pest }

  function matas: boolean;
  { tikrina, ar juod—j— karaliui matas }
  { n, len, fig - globalieji kintamieji }
    var i: integer;
        saugu: boolean;
  begin
     saugu := false;
     i := 1;
     while (i <= n) and not saugu do
       begin  { tikrinsime, ar galime ižsigelb‚ti pa‚jŠ i-t…j… fig–ra }
         with fig[i] do
           if s = juoda  { jei tai juodoji fig–ra, bandome ja paeiti }
              then case t of  { s‚kmingas ‚jimas Ťsimenamas fig[0] }
                     pestininkas: saugu := ej_pest (i);
                     zirgas     : saugu := ej_zirgas (i);
                     rikis      : saugu := ej_rikis (i);
                     bokstas    : saugu := ej_bokstas (i);
                     valdove    : saugu := ej_valdove (i);
                     karalius   : saugu := ej_karalius (i)
                   end;
         i := i + 1;
       end;
    matas := not saugu
  end;

  { ****************** pagrindin‚ programos dalis ********************* }
  function tipo_raide (tp: tipas): char;
  begin
    case tp of
      pestininkas: tipo_raide := 'P';
      zirgas     : tipo_raide := 'Z';
      rikis      : tipo_raide := 'R';
      bokstas    : tipo_raide := 'B';
      valdove    : tipo_raide := 'V';
      karalius   : tipo_raide := 'K'
    end;
  end;

  var f: text;
begin
  ivesti; { n, fig, len - globalieji }
  assign (f, 'SACHM.REZ');
  rewrite (f);
   if sachas { n, fig, len - globalieji }
      then if matas { n, fig, len - globalieji }
         then write (f, 'MATAS')
         else begin
                if fig[0].s = balta
                   then write (f, 'b')
                   else write (f, 'j');
                write (f, tipo_raide(fig[0].t), fig[0].k.x, fig[0].k.y)
              end
      else writeln (f, 'NEźACHUOJAMA');
   close (f)
end.