  { 135 u‘davinys }

unit labir;

interface

  function dydis : integer; { gra‘ina labirinto dy }

  function siaure : boolean; { ar galima jud‚ti nurodytomis kryptimis }
  function pietus : boolean;
  function rytai : boolean;
  function vakarai : boolean;

  procedure pirmyn;  { atlieka ‚jimus nurodytomis kryptimis }
  procedure atgal;
  procedure kairen;
  procedure desinen;


implementation
  const max = 200; { maksimalus labirinto dydis }
  type lab = array [0..max + 1, 0..max + 1] of boolean;
       kryptis = (s, r, p, v); { žiaur‚, rytai, piet–s, vakarai }

  { global–s kintamieji }
  var n : longint; { labirinto dydis }
      y, x,   { i‚jimo koordinat‚s }
      zingsniai, iy, ix  : integer;
      l : lab; { labirintas }
      krypt : kryptis;

  function dydis : integer;
  begin
    dydis := n;
  end;

  function siaure : boolean;
  begin
    siaure := l[y - 1, x];
  end;

  function pietus : boolean;
  begin
    pietus := l[y + 1, x];
  end;

  function rytai : boolean;
  begin
    rytai := l[y, x + 1];
  end;

  function vakarai : boolean;
  begin
    vakarai := l[y, x - 1];
  end;

  function succ_k (k : kryptis) : kryptis;
  begin
    if k = v
       then succ_k := s
       else succ_k := succ(k);
  end;

  procedure ejimas;
    { atliekamas ‚jimas }
  begin
    if zingsniai > n * n
       then begin
              writeln ('Viržytas ‘ingsni— skai‡ius: ', zingsniai);
              halt (1)
            end;
    { pajudama nurodyta kryptimi }
    case krypt of
     s : y := y - 1;
     p : y := y + 1;
     r : x := x + 1;
     v : x := x - 1;
    end;
    { patirkinama, ar atliktas korektižkas ‚jimas }
     if ((y in [1, n]) or (x in [1, n])) and l[y, x] and
        ((y <> iy) or (x <> ix))   { jei pasiektas iž‚jimas }
        then begin
               zingsniai := zingsniai + 1;
               write ('Pasiektas iž‚jimas', y : 4, x : 4);
               writeln (' per ', zingsniai, ' ‘ingsni—(us).');
               halt (1);
             end
        else if l[y, x]   { jei padarytas korektižkas ‚jimas }
                then zingsniai := zingsniai + 1
                else begin  { jei padarytas negalimas ‚jimas }
                       writeln ('Negalimas ‚jimas', y : 4, x : 4);
                       halt (1);
                     end;
  end;

  procedure pirmyn;
  begin
    ejimas;
  end;

  procedure atgal;
  begin
    krypt := succ_k(succ_k(krypt));
    ejimas;
  end;

  procedure kairen;
  begin
    krypt := succ_k(succ_k(succ_k(krypt)));
    ejimas;
  end;

  procedure desinen;
  begin
    krypt := succ_k(krypt);
    ejimas;
  end;


  const byla = 'lab.dat';
  var i, j : integer;
      f : text;
      c : char;
begin
  assign (f, byla);
  reset (f);
  readln (f, n, y, x);   { perskaitomas dydis, i‚jimo tažkas }
  iy := y; ix := x;
  { inicializuojamas labirintas }
  for i := 1 to n do
    begin
      l[0, i] := false;
      l[i, 0] := false;
      l[n + 1, i] := false;
      l[i, n + 1] := false;
    end;
  { nuskaitomas labirintas }
  for i := 1 to n do
    begin
      for j := 1 to n do
        begin
          read (f, c);
          if c = '#'
             then l[i, j] := false
             else l[i, j] := true;
        end;
      readln (f);
    end;
  close (f);
  { inicializuojamas ‘ingsni— skai‡ius }
  zingsniai := 0;
  { nustatoma, iž kurios pus‚s yra ‚jimas  labirint… }
  { t. y. randama ‘i–r‚jimo kryptis }
  if y = 1
    then krypt := p
    else if y = n
            then krypt := s
    else if x = 1
            then krypt := r
    else if x = n
            then krypt := v
    else begin
           writeln ('Nekorektižkos i‚jimo koordinat‚s', y : 4, x : 4);
           halt (1);
         end;
end.