PROGRAM SECHS4(INPUT,OUTPUT);                               
(*SIEHE AUCH N. WIRTH ALGO. & DATENSTRUKTUREN S.196       *)
                                                            
CONST MAXN=8;                                               
TYPE INDEX=1..MAXN;                                         
VAR N,I,J:INDEX;                                            
    NQ   :INTEGER;                                          
    Q    :BOOLEAN;                                          
    A,B  :ARRAY[1..8]OF INTEGER;                            
    H    :ARRAY[INDEX,INDEX]OF INTEGER;                     
                                                            
 PROCEDURE TRY(I:INTEGER;X,Y:INDEX);                        
 (*VERSUCHE DEN NAECHSTEN ZUG:                        *)    
                                                            
 VAR K,U,V:INTEGER;                                         
                                                            
 BEGIN                                                      
  K:=1;                                                     
  REPEAT (*FUER ALLE SPRUNGRICHTUNGEN:*)                    
   U:=X+A[K];V:=Y+B[K];                                     
   IF(U>0)AND(U<=N)AND(V>0)AND(V<=N) THEN                   
   IF H[U,V]=0 THEN                                         
    (*ZIELFELD FREI UND AUF DEM BRETT*)                     
    BEGIN                                                   
     H[U,V]:=I;(*NOTIERE ZUG, BESETZE FELD*)                
     IF I<NQ THEN                                           
      BEGIN                                                 
       (*FALLS NOCH NICHT ALLE ZUEGE WEITERZIEHEN*)         
       TRY(I+1,U,V);                                        
       (*BEI MISSERFOLG ZUG RUECKGAENGIG MACHEN*)           
       IF NOT Q THEN H[U,V]:=0                              
      END                                                   
     ELSE                                                   
      Q:=TRUE                                               
    END;                                                    
   K:=K+1                                                   
  (*BIS ERFOLG ODER KEINE ZUGMOEGLICHKEIT MEHR*)            
  UNTIL Q OR (K>8);                                         
 END;                                                       
                                                            
BEGIN                                                       
 (*OFFSET FUER SPRINGERZUEGE INITIALISIEREN:*)              
 A[1]:= 2;B[1]:= 1;                                         
 A[2]:= 1;B[2]:= 2;                                         
 A[3]:=-1;B[3]:= 2;                                         
 A[4]:=-2;B[4]:= 1;                                         
 A[5]:=-2;B[5]:=-1;                                         
 A[6]:=-1;B[6]:=-2;                                         
 A[7]:= 1;B[7]:=-2;                                         
 A[8]:= 2;B[8]:=-1;                                         
                                                            
 (*PROBLEMPARAMETER EINLESEN:*)                             
 READLN(N);NQ:=N*N;                                         
 (*FELD LOESCHEN:*)                                         
 FOR I:=1 TO N DO                                           
  FOR J:=1 TO N DO H[I,J]:=0;                               
 READLN(I,J);                                               
 (*START DER SUCHE*)                                        
 H[I,J]:=1;Q:=FALSE;TRY(2,I,J);                             
                                                            
 IF Q THEN                                                  
 (*LOESUNG DRUCKEN:*)                                       
  FOR I:=1 TO N DO                                          
   BEGIN                                                    
    FOR J:=1 TO N DO WRITE(H[I,J]);                         
    WRITELN                                                 
   END                                                      
 ELSE                                                       
  WRITELN("KEINE LOESUNG");                                 
END.