PROGRAM MARRIAGE(INPUT,OUTPUT);                   
(*N. WIRTH: ALGORITHMEN UND DATENSTRUKTUREN     *)
(*S. 210  2.3.1985 FLORIAN MATTHES              *)
 CONST N=8;                                       
 TYPE MAN=1..N;WOMAN=1..N;RANK=1..N;              
 VAR M:MAN;W:WOMAN;R:RANK;                        
     WMR:ARRAY[MAN  ,RANK ]OF WOMAN;              
     MWR:ARRAY[WOMAN,RANK ]OF MAN;                
     RMW:ARRAY[MAN  ,WOMAN]OF RANK;               
     RWM:ARRAY[WOMAN,MAN  ]OF RANK;               
     X  :ARRAY[MAN] OF WOMAN;                     
     Y  :ARRAY[WOMAN] OF MAN;                     
     SINGLE:ARRAY[WOMAN]OF BOOLEAN;               
                                                  
 PROCEDURE PRINT;                                 
  VAR M:MAN;RM,RW:INTEGER;                        
 BEGIN RM:=0;RW:=0;                               
  FOR M:=1 TO N DO                                
   BEGIN WRITE(X[M]:4);                           
    RM:=RM+RMW[M,X[M]];RW:=RW+RWM[X[M],M]         
   END;                                           
  WRITELN(RM:8,RW:4)                              
 END;(*PRINT*)                                    
                                                  
 PROCEDURE TRY(M:MAN);                            
  VAR R:RANK; W:WOMAN;                            
                                                  
  FUNCTION STABLE:BOOLEAN;                        
   VAR PM:MAN; PW:WOMAN;                          
       I,LIM:RANK;S:BOOLEAN;                      
                                                  
  BEGIN S:=TRUE;I:=1;                             
   WHILE (I<R) AND S DO                           
    BEGIN PW:=WMR[M,I];I:=I+1;                    
     IF NOT SINGLE[PW] THEN                       
        S:=RWM[PW,M]>RWM[PW,Y[PW]]                
    END;                                          
   I:=1;LIM:=RWM[W,M];                            
   WHILE (I<LIM) AND S DO                         
    BEGIN PM:=MWR[W,I];I:=I+1;                    
     IF PM<M THEN S:=RMW[PM,W]>RMW[PM,X[PM]]      
    END;                                          
   STABLE:=S                                      
  END;(*STABLE*)                                  
                                                  
 BEGIN (*TRY*)                                    
  FOR R:=1 TO N DO                                
  BEGIN W:=WMR[M,R];                              
   IF SINGLE[W] THEN                              
    IF STABLE THEN                                
     BEGIN X[M]:=W;Y[W]:=M;SINGLE[W]:=FALSE;      
      IF M<N THEN TRY(SUCC(M)) ELSE PRINT;        
      SINGLE[W]:=TRUE                             
     END                                          
  END                                             
 END;(*TRY*)                                      
                                                  
BEGIN                                             
 FOR M:=1 TO N DO                                 
  FOR R:=1 TO N DO                                
   BEGIN READ(WMR[M,R]);RMW[M,WMR[M,R]]:=R        
   END;                                           
 FOR W:=1 TO N DO                                 
  FOR R:=1 TO N DO                                
   BEGIN READ(MWR[W,R]);RWM[W,MWR[W,R]]:=R        
   END;                                           
 FOR W:=1 TO N DO SINGLE[W]:=TRUE;                
 TRY(1)                                           
END.