PROGRAM SORTTEST(INPUT,OUTPUT);                   
 CONST N=16;                                      
 VAR A:ARRAY[1..N]OF INTEGER;                     
     P:TEXT;                                      
                                                  
 PROCEDURE GEN;                                   
  VAR I:INTEGER;                                  
      D:TEXT;                                     
 BEGIN                                            
  OPEN(D,8,3,"D,S,R");                            
  FOR I:=1 TO N DO READ(D,A[I]);                  
  CLOSE(D)                                        
 END;                                             
                                                  
 PROCEDURE OUT;                                   
  VAR I:INTEGER;                                  
 BEGIN                                            
  FOR I:=1 TO N DO WRITE(P,A[I]:3);               
  WRITELN(P);                                     
 END;                                             
                                                  
 PROCEDURE HEAP;                                  
  VAR L,R,X:INTEGER;                              
                                                  
  PROCEDURE EINFUEGEN;                            
  (*A[L] IN HEAP A[L+1..R] EINFUEGEN*)            
   LABEL 1;                                       
   VAR I,J:INTEGER;                               
  BEGIN                                           
   X:=A[L];I:=L;J:=2*I;                           
   WHILE J<=R DO                                  
    BEGIN                                         
     IF J<R THEN                                  
       IF A[J]<A[J+1] THEN J:=J+1;                
     IF X>A[J] THEN GOTO 1;                       
     A[I]:=A[J];I:=J;J:=2*I                       
    END;                                          
   1:A[I]:=X;OUT                                  
  END;(*EINFUEGEN*)                               
                                                  
 BEGIN                                            
  L:=N DIV 2+1;R:=N;                              
  WHILE L>1 DO                                    
   BEGIN L:=L-1;EINFUEGEN END;                    
  WHILE R>1 DO                                    
   BEGIN X:=A[R];A[R]:=A[L];A[L]:=X;              
         R:=R-1;EINFUEGEN                         
   END;                                           
 END;(*HEAP*)                                     
                                                  
BEGIN                                             
 OPEN(P,4,0,"");                                  
 GEN;OUT;HEAP;                                    
 CLOSE(P)                                         
END.