PROGRAM DECODE(INPUT,OUTPUT);                                                   
(*23.6.1985*)                                                                   
 CONST MAX=97;L1=3;L2=6;MAXR=13;                                                
       CSTSYM=9 ;JMCSYM=19;                                                     
       MONSYM=72;DYASYM=73;LRCSYM=68;                                           
 VAR OP:ARRAY[0..MAX]OF RECORD                                                  
                         C:ARRAY[0..2]OF CHAR;                                  
                         T1,T2:CHAR                                             
                        END;                                                    
     ROP:ARRAY[0..MAXR,0..2]OF CHAR;                                            
     D:TEXT;                                                                    
     PC,LAST,X,Y:INTEGER;                                                       
     Z:CHAR;                                                                    
                                                                                
 PROCEDURE INPUT;                                                               
  VAR I:INTEGER;C1,C2:CHAR;                                                     
      F:TEXT;                                                                   
 BEGIN                                                                          
  OPEN(F,8,3,"CODETAB,S,R");                                                    
  FOR I:= 0 TO MAX DO                                                           
   WITH OP[I] DO                                                                
   BEGIN                                                                        
    READLN(F,C[0],C[1],C[2],T1,T2)                                              
   END;                                                                         
  FOR I:= 0 TO MAXR DO                                                          
    READLN(F,ROP[I,0],ROP[I,1],ROP[I,2],C1,C2);                                 
  CLOSE(F)                                                                      
 END;                                                                           
                                                                                
 FUNCTION SHORT:INTEGER;                                                        
 BEGIN SHORT:=PEEK(PC);PC:=PC+1 END;                                            
                                                                                
 FUNCTION DEEK:INTEGER;                                                         
  CONST BUF1=826;BUF2=827;                                                      
  VAR I:INTEGER[BUF1];                                                          
 BEGIN                                                                          
  POKE(BUF1,PEEK(PC  ));                                                        
  POKE(BUF2,PEEK(PC+1));                                                        
  DEEK:=I                                                                       
 END;                                                                           
                                                                                
 PROCEDURE BYTE;                                                                
 BEGIN WRITE(D,SHORT:L1) END;                                                   
                                                                                
 PROCEDURE ADR;                                                                 
 BEGIN WRITE(D,DEEK:L2);PC:=PC+2 END;                                           
                                                                                
BEGIN                                                                           
 WRITE("START:");READLN(PC);                                                    
 WRITE("ENDE :");READLN(LAST);                                                  
 WRITE("DRUCKER: N?");READLN(Z);                                                
 IF Z="J" THEN OPEN(D,4,0)                                                      
          ELSE OPEN(D,3,0);                                                     
 INPUT;                                                                         
 WHILE PC<=LAST DO                                                              
  BEGIN                                                                         
   X:=SHORT;WRITE(D,PC-1:L2);                                                   
   IF X>MAX THEN WRITELN(D,"???":4,X:L1) ELSE                                   
   WITH OP[X] DO                                                                
   BEGIN                                                                        
    WRITE(D,C:4);                                                               
    CASE T1 OF                                                                  
     "A":ADR;                                                                   
     "B":BYTE;                                                                  
     "X":CASE X OF                                                              
          CSTSYM:BEGIN Y:=DEEK;ADR;WRITE(D,"'");                                
                  WHILE PC<Y DO WRITE(D,CHR(SHORT));                            
                  WRITE(D,"'")                                                  
                 END;                                                           
          JMCSYM:BEGIN ADR;Y:=SHORT;                                            
                  WHILE Y>0 DO BEGIN ADR;Y:=Y-1 END;                            
                 END;                                                           
          MONSYM,DYASYM:WRITE(D, ROP[SHORT]:L1);                                
          LRCSYM:BEGIN BYTE;ADR;ADR END                                         
         END;                                                                   
     " ":WRITE(D," ":L2)                                                        
    END;(*CASE*)                                                                
    CASE T2 OF                                                                  
     "A":ADR;                                                                   
     "B":BYTE;                                                                  
     " ":                                                                       
    END;                                                                        
    WRITELN(D);                                                                 
   END                                                                          
  END;                                                                          
 CLOSE(D)                                                                       
END.