{
TASK: ZODIS
LANG: PASCAL
}

program zodis;

const byla = 'ZODIS.DAT';
      rez  = 'ZODIS.REZ';
      maxN = 81;
      maxK = 256;
//-------------------------------------------------------------
type TSluoksnis = record
                    kiek : integer;
                    vietos : array[1..maxK] of integer;
                  end;
     TKelias = array[0..maxK+1] of integer;
//-------------------------------------------------------------
   var N:integer;
       K:integer;
       zod : string;
       Sluoksniai : array[1..maxK] of TSluoksnis;
       kelioIvertis : integer;
       rastasKelias: TKelias;
       kelioBaziniuTasku : integer;
       ivertintaKeliu : longint;
       // Sia lentele naudojame, kai N < maxN:
       atstumuLentele : array[1..(maxN div 2)*(maxN div 2),
                              1..(maxN div 2)*(maxN div 2)] of byte;


//-------------------------------------------------------------
  procedure skaityk;
   var f :text;
       i,j,kel : integer;
       s : string;

    procedure ismeskPasikartuojancius;
     var zod1 : string;
         i   : integer;
         aibe : set of char;
    begin
      zod1:='';
      aibe:=[];
      for i:=1  to length(zod) do
          begin
           if not (zod[i] in aibe)
              then begin
                 zod1:=zod1+zod[i];
                 aibe:=aibe+[ zod[i] ];
              end;
           end;
       zod:=zod1;
    end;


  begin // Skaitymo
   assign(f,byla);
   reset(f);
   readln(f,N);
   readln(f,zod);
   ismeskPasikartuojancius;
   K:=length(zod);
   for i:=1 to K do
    Sluoksniai[i].kiek:=0;

   for i:=1 to N do
      begin
         readln(f,s);
         for j:=1 to N do
         begin
           kel:=Pos(s[j],zod);
           if kel > 0 then
             begin
              Sluoksniai[kel].kiek:=Sluoksniai[kel].kiek+1;
              Sluoksniai[kel].vietos[Sluoksniai[kel].kiek]:=(i-1)*N+j;
             end;
          end;
      end;
   close(f);
  end;// Skaitymo
//-------------------------------------------------------------
  procedure spresk;

     var i, kiekVariantu : longint;
        //----------------------------------------------------------
     procedure generuokVariantus;

       var eil,stl,i,t,kk,idxEil,Nuo,Iki,kelioTasku : integer;
           v,vv,kelioVariantu,j,jj :longint;
           ivertinimas:integer;
           variantas : array[1..maxK] of integer;
           kelias,kelias2 : TKelias;
           eiluciuIndeksai : array[1..maxK] of integer;

       //------------------------------------------------------

       procedure sort;
         var idx,i,j,min,max : integer;
       begin
          idx:=0;
          idxEil:=0;
          for i:=1 to N do
          begin
           min:=maxint;
           max:=0;
           for j:=0 to K+1 do begin
            eil:=(kelias[j]-1) div N + 1;
            if eil=i then begin
             if kelias[j]>max then max:=kelias[j];
             if kelias[j]<min then min:=kelias[j];
            end;
           end;
           if min < max then
             begin
              kelias2[idx]:=min;
              inc(idxEil);
              eiluciuIndeksai[idxEil]:=idx;
              inc(idx);
              kelias2[idx]:=max;
              inc(idx);

             end
             else if min=max then
              begin
               kelias2[idx]:=min;
               inc(idx);
              end;
          end;

          kelias:=kelias2;
          kelioTasku:=idx-1;

       end;

       //------------------------------------------------------
       function atstumas(a,b:integer):longint;
        var r,aN,bN : longint;
        begin
         r:=abs((a-1) div N - (b-1) div N);
         aN:=a mod N;
         if aN = 0 then aN:=N;
         bN:=b mod N;
         if bN = 0 then bN:=N;
         atstumas:=r+abs(aN-bN);
        end;

       //------------------------------------------------------

      begin
      // Kai  K=1 - svarbus ribinis atvejis

         if K=1 then begin
          kelioIvertis := 2 * N - 1;
          kelioBaziniuTasku:=2;
          rastasKelias[0]:=1;
          rastasKelias[1]:=sluoksniai[1].vietos[2];
          rastasKelias[2]:=N*N;
          exit;
         end;

      // -------------------------
      // Atstumai:
         for i:=1 to N*N do
          for j:=1 to N*N do atstumuLentele[i,j]:=atstumas(i,j);

     // Variantai:
         v:=0;
         while v < kiekVariantu do // Pagal sluoksnius
         begin
         vv := v;
         for i:=1 to K do begin
           variantas[i] := vv mod Sluoksniai[i].kiek;
           kelias[i] := Sluoksniai[i].vietos[variantas[i]+1];
           vv := vv div Sluoksniai[i].kiek;
          end;

         kelias[0]:=1;
         kelias[K+1]:=N*N;
         sort;

         Nuo:=1;
         if eiluciuIndeksai[Nuo]=0 then Inc(Nuo);

         Iki:=idxEil;
         if kelias[kelioTasku-1] > ( (N-1)*N ) then Dec(Iki);

         if Iki >= Nuo then kelioVariantu := 1 shl (Iki - Nuo + 1)
                       else kelioVariantu := 0;

         for j := 0 to kelioVariantu do //Pagal subvariantus
         begin
         jj:=j;
         kelias:=kelias2;
         for kk:=Nuo to Iki do
           begin
             if jj mod 2 = 1 then begin
                    t:=kelias[ eiluciuIndeksai[kk] ];
                    kelias[ eiluciuIndeksai[kk] ]:=kelias[eiluciuIndeksai[kk]+1];
                    kelias[eiluciuIndeksai[kk]+1]:=t;
                  end;
             jj:=jj div 2;
           end;

         ivertinimas:=1;
         for i:=0 to kelioTasku-1 do
          ivertinimas:=ivertinimas+atstumuLentele[kelias[i],kelias[i+1]];
         inc(ivertintaKeliu);
         if ivertinimas < kelioIvertis
           then begin
                  kelioIvertis:=ivertinimas;
                  rastasKelias:=kelias;
                  kelioBaziniuTasku:=kelioTasku;
                end;
         end;  // pagal subvariantus
        inc(v);  // Kitas variantas
        end;  // pagal  sluoksnius
      end; //Generatoriaus variantu


  begin  // Sprendimo
      kelioIvertis:=4*N*N;
      kiekVariantu:=1;
      ivertintaKeliu:=0;
      for i:=1 to K do kiekVariantu := kiekVariantu * Sluoksniai[i].kiek;
      generuokVariantus;
  end;  // Sprendimo
 //-----------------------------------------------------------------------
 procedure rasyk;
    var f,ht : text;
        i:integer;

    //   Procedura  kelio  rasymui
   procedure rasykKeliaNuoIki(nuo,iki : integer);

      var sg,ee,ss,e1,s1,e2,s2 : integer;

     begin
        e1:=( nuo - 1 ) div N + 1;
        e2:=( iki - 1 ) div N + 1;
        s1:=( nuo - 1 ) mod N + 1;
        s2:=( iki - 1 ) mod N + 1;
        if e1 < e2 then
           for ee := e1+1 to e2 do writeln(f,ee,' ',s1);
        sg:=1; if s1 > s2 then sg:=-1;
        for ss:=1 to abs( s2 - s1) do
          writeln(f,e2,' ',s1+sg*ss);

     end;


  begin
    assign(f,rez);
    rewrite(f);
    writeln(f,kelioIvertis);
    writeln(f,'1 1');  //  Pirmas  narvelis

    for i:=0 to kelioBaziniuTasku-1 do
     begin
       rasykKeliaNuoIki(rastasKelias[i], rastasKelias[i+1]);
     end;
    close(f);

  end;
 //-------------------------------------------------------------------------

 begin
   skaityk;
   spresk;
   rasyk;
 end.