         Edinburgh IMP77 Compiler - Version 8.4

    1 %BEGIN;                               !HAL-70
		.Ltext0:
		CHAR.6:
		.LVL0:
		.LFB232:
				endbr64
				pushq	%r15
				pushq	%r14
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$1416, %rsp
				movq	%fs:40, %rax
		
				movq	%rax, 1400(%rsp)
		
				xorl	%eax, %eax
				leaq	1472(%rsp), %rax
		
				movq	%rax, 104(%rsp)
    2 !    INPUT/OUTPUT STREAMS
    3 %OWNINTEGER MAIN=1, PRE=2;            !INPUT
				call	_imp_initialise@PLT
		.LVL630:
    4 %OWNINTEGER BIN=1, LIS=2;             !OUTPUT
    5 !    OPERAND TYPES
    6 %OWNINTEGER OPMASK=16_F000;           !MACHINE INSTRUCTION OR MACRO
    7 %OWNINTEGER MACRO=16_A000
    8 %OWNINTEGER SINGLE=16_5000
    9 %OWNINTEGER FMASK=16_0800;            !FORWARD REF
   10 %OWNINTEGER OPFMASK=16_F800;          !=OPMASK+FMASK
   11 %OWNINTEGER UMASK=16_0200;            !UNDEF (FORWARD REF)
   12 %OWNINTEGER BMASK=16_0100;            !BYTE
   13 %OWNINTEGER REG=16_0080;              !REGISTER
   14 %OWNINTEGER MEMMASK=16_0040;          !MEM REF
   15 %OWNINTEGER RELMASK=16_0020;          !RELOCATABLE
   16 %OWNINTEGER XMASK=16_0010;            !INDEXED
   17 %OWNINTEGER REGXMASK=16_0090;         !=REG+XMASK
   18 %OWNINTEGER RELUXMASK=16_0230;        !=RELMASK+UMASK+XMASK
   19 !    TEXT POINTERS (BYTE ADDRESSES)
   20 %OWNINTEGER CODEPOS;                  !(NOT ACTUALLY BYTE)
   21 %OWNINTEGER STARTPOS;                 !START OF CURRENT LINE
   22 %OWNINTEGER GETPOS;                   !INPUT POINTER (NEXT)
   23 %OWNINTEGER PUTPOS
   24 %OWNINTEGER PSEUDOLIM
   25 %OWNINTEGER PRINTPOS;                 !START OF PRINT LINE
   26 %OWNINTEGER FAULTPOS
   27 %OWNINTEGER MACLIM;                   !MACRO DEF LIMIT
   28 !    OTHER POINTERS (WORD ADDRESSES)
   29 %OWNINTEGER MP;                       !MACRO-CALL PARAMETERS
   30 %OWNINTEGER QBASE,QSTART,QLIM,TRANSF; !OPERAND QUEUE
   31 %OWNINTEGER DEFMIN;                   !TAG MIN (DOWN - RESET)
   32 %OWNINTEGER DEFLIM;                   !TAG LIM (FIXED)
   33 %OWNINTEGER ALMAX;                    !ASSEMBLER LAB MAX (UP - RESET)
   34 %OWNINTEGER LABMIN;                   !USER LAB MIN (DOWN - RESET)
   35 %OWNINTEGER LABLIM;                   !USER LAB LIM (FIXED)
   36 %OWNINTEGER BP;                       !BLOCK POINTER (UP - DOWN)
   37 %OWNINTEGER NP;                       !NEST POINTER (DOWN - UP)
   38 %OWNINTEGER STORELIM;                 !(FIXED)
   39 
   40 %INTEGER SYM;                         !CURRENT SYMBOL
   41 %INTEGER TERM;                        !TAG TERMINATOR
   42 %INTEGER FSYM;                        !FAULT FLAG SYMBOL
   43 %OWNINTEGER CHARS=0;                  !PRINT CHAR COUNT
   44 %OWNINTEGER LINES=0;                  !PRINT LINE COUNT
   45 %OWNINTEGER BINCOUNT=0;               !OUTPUT RECORD ITEM COUNT
   46 %OWNINTEGER CHECK=0;                  !OUTPUT RECORD CHECKSUM
   47 %OWNINTEGER PASS=-1;                  !CURRENT PASS (-1,0,1)
   48 %OWNINTEGER LIST=-1;                  !LISTING CONTROL
   49 %INTEGER ASSCOND,SKIP;                !ASSEMBLY CONDITIONS (BIT NEST)
   50 %OWNINTEGER SAVE=1;                   !REG SAVE DISPLACEMENT
   51 %OWNINTEGER TEMPS=12;                 !TEMPORARY REGISTER SET (2,3)
   52 %INTEGER LOCTYPE,LOC;                 !LOCATION COUNTER
   53 %INTEGER ACC,ATYPE,AVAL;              !MAIN TEMP REGISTER
   54 %INTEGER CREG,CTYPE,CVAL;             !CONDITION CODE
   55 %INTEGER COND;                        !CONDITION CODE MASK
   56 %INTEGER DREG,DUSE;                   !DESTINATION REGISTER
   57 %INTEGER TYPE,VAL;                    !CURRENT TYPE,VALUE
   58 %INTEGER TAG1,TAG2;                   !TAG (CHARS 1:3, 4:6)
   59 %INTEGER MODE;                        !ASSEMBLY MODE
   60 %INTEGER PEND;                        !TAG ALREADY RECOGNISED
   61 %INTEGER FLAG;                        !JUMPS / AHM
   62 %OWNINTEGER QQ='?'
   63 
   64 %OWNINTEGERARRAY BREC(1:52);          !BINARY OUTPUT RECORD
   65 
   66 !!%INTEGER SBOUND
   67 %constINTEGER SBOUND = 16_7F00
   68 !!    SBOUND = FREESTORE-260;           !ALLOW FOR INPUT BUFFER
   69 !!    SBOUND = SBOUND-256 %IF OUTDEV = 2
   70     SELECT OUTPUT(LIS)
		.LBB189:
		.LBI189:
   71 !!    SBOUND = SBOUND-256 %IF OUTDEV = 2
   72 
   73 !! Simulate 18-bit word-addressed PDP9/15 memory:
   74 
   75 %ownINTEGERARRAY STORE(1:SBOUND)
   76 
   77 %integerfn integer(%integer p)
				pushq	%rbx
				subq	$528, %rsp
				movl	%edi, %ebx
				movq	%fs:40, %rax
		
				movq	%rax, 520(%rsp)
		
				xorl	%eax, %eax
   78     %if p&1 # 0 %start
				testb	$1, %dil
				jne	.L131
		.LDL26:
   79       printstring("Integer fetch was not aligned at "); write(p, -1); newline
				movabsq	$2338042651316874825, %rax
		
				movabsq	$7023117776624837990, %rdx
		
				movq	%rax, 1(%rsp)
				movq	%rdx, 9(%rsp)
				movabsq	$7809558913294934131, %rax
		
				movabsq	$8386019596711126889, %rdx
		
				movq	%rax, 17(%rsp)
				movq	%rdx, 25(%rsp)
				movq	$32, 33(%rsp)
		
				movq	$0, 41(%rsp)
		
				movq	$0, 49(%rsp)
		
				movq	$0, 57(%rsp)
		
				movq	$0, 65(%rsp)
		
				movq	$0, 73(%rsp)
		
				movq	$0, 81(%rsp)
		
				movq	$0, 89(%rsp)
		
				movq	$0, 97(%rsp)
		
				movq	$0, 105(%rsp)
		
				movq	$0, 113(%rsp)
		
				movq	$0, 121(%rsp)
		
				movq	$0, 129(%rsp)
		
		
				movq	$0, 137(%rsp)
		
		
				movq	$0, 145(%rsp)
		
		
				movq	$0, 153(%rsp)
		
		
				movq	$0, 161(%rsp)
		
		
				movq	$0, 169(%rsp)
		
		
				movq	$0, 177(%rsp)
		
		
				movq	$0, 185(%rsp)
		
		
				movq	$0, 193(%rsp)
		
		
				movq	$0, 201(%rsp)
		
		
				movq	$0, 209(%rsp)
		
		
				movq	$0, 217(%rsp)
		
		
				movq	$0, 225(%rsp)
		
		
				movq	$0, 233(%rsp)
		
		
				movb	$33, (%rsp)
		.LBB75:
		.LBI75:
				addq	$256, %rsp
				movl	$-1, %esi
				movl	%ebx, %edi
				call	_imp_writeint@PLT
		.LVL102:
		.LBB77:
		.LBI77:
   80       %stop
				movl	$0, %edi
				call	exit@PLT
		.LVL104:
		.L135:
   81     %finish
   82     %result = store(P>>1)
				shrl	%ebx
				movslq	%ebx, %rbx
				leaq	-4+STORE.133(%rip), %rax
				movl	(%rax,%rbx,4), %eax
   83 %end
   84 
				movq	520(%rsp), %rdx
		
				subq	%fs:40, %rdx
		
				jne	.L135
				addq	$528, %rsp
				popq	%rbx
				ret
		.LVL100:
		.L131:
				call	__stack_chk_fail@PLT
		.LVL105:
		.LFE231:
		SETLAB.10:
		.LVL106:
		.LFB251:
   85 %INTEGERFN CHAR(%INTEGER P)
   86 !BYTE FETCH
   87 
   88     %integer val = store(p>>1)
				movl	%edi, %eax
				shrl	%eax
				cltq
				leaq	-4+STORE.133(%rip), %rdx
				movl	(%rdx,%rax,4), %eax
		.LVL1:
   89     %if p&1 = 0 %start
   90       %result = val&255
   91     %else
   92       %result = (val>>8)&255
				movzbl	%ah, %edx
				movzbl	%al, %eax
		.LVL2:
				testb	$1, %dil
				cmovne	%edx, %eax
   93     %finish
   94     
   95 !!    %OPR 2064;!RCR;  %DAC P
   96 !!    %LAC* P;  %OPR 768;!SZL;  %JMP L1
   97 !!    %OPR 1040;!RTR;  %OPR 1040
   98 !!    %OPR 1040;  %OPR 1040
   99 !!L1: %AND #255;  %JMP* CHAR
  100 !!    %STOP
  101 
  102 %END
  103 
				ret
		.LFE232:
		SETINTEGER.8:
		.LVL3:
		.LFB233:
  104 %routine set integer(%integer p, k)
  105     store(p>>1) = k
				shrl	%edi
		.LVL4:
				movslq	%edi, %rdi
				leaq	-4+STORE.133(%rip), %rax
				movl	%esi, (%rax,%rdi,4)
  106 %end
  107 
  108 %ROUTINE PUT CHAR(%INTEGER K)
				ret
		.LFE233:
		PUTCHAR.37:
		.LVL5:
		.LFB234:
  109 !AT PUTPOS WITH POST-INCREMENT
		.LBB172:
		.LBB174:
				leaq	.LC0(%rip), %r8
				cmovne	%rax, %r8
				movl	%ebp, %ecx
				leaq	.LC2(%rip), %rdx
				movl	$2, %esi
				movq	stderr(%rip), %rdi
				movl	$0, %eax
				call	__fprintf_chk@PLT
		.LVL588:
		.LBE174:
		.LBE173:
  110 %INTEGER P
  111 !!    %MONITOR 21 %IF PUTPOS>>1-DEFMIN >= 0
				leaq	.LC0(%rip), %r8
				cmovne	%rax, %r8
				movl	%ebp, %ecx
				leaq	.LC1(%rip), %rdx
				movl	$2, %esi
				movq	stderr(%rip), %rdi
				movl	$0, %eax
				call	__fprintf_chk@PLT
		.LVL451:
		.LBE172:
		.LBE171:
  112 !{}    %signal 2,1 %IF PUTPOS>>1-DEFMIN >= 0
  113 
  114     p = store(putpos>>1)
				movl	PUTPOS.95(%rip), %eax
				movl	%eax, %edx
				shrl	%edx
				movslq	%edx, %rdx
				leaq	STORE.133(%rip), %rcx
				leaq	-4(%rcx,%rdx,4), %rcx
				movl	(%rcx), %edx
		.LVL6:
  115     %if putpos&1 = 0 %start
				testb	$1, %al
				je	.L6
		.LDL1:
  116       p = (p&16_FF00) ! (K&255)
				andl	$65280, %edx
		.LVL11:
				movzbl	%dil, %edi
		.LVL12:
				orl	%edx, %edi
		.LVL13:
  117     %else
				jmp	.L7
		.LFE234:
		FAULT.45:
		.LVL14:
		.LFB235:
  118       p = (p&16_00FF) ! ((K&255)<<8)
				movzbl	%dl, %edx
		.LVL7:
				sall	$8, %edi
		.LVL8:
				movzwl	%di, %edi
				orl	%edx, %edi
		.LVL9:
		.L7:
  119     %finish
  120     store(putpos>>1) = p
				movl	%edi, (%rcx)
  121 
  122 !!    %LAC PUTPOS;  %OPR 2064;!RCR;  %DAC P
  123 !!    %OPR 768;!SZL;  %JMP L1
  124 !!    %LAC K;  %OPR 1032;!RTL;  %OPR 1032
  125 !!    %OPR 1032;  %OPR 1032;  %DAC K
  126 !!    %LAC #-256;  %OPR 513;!SKP!CMA
  127 !!L1: %LAC #-256;  %AND* P;  %TAD K;  %DAC* P
  128 !!    %ISZ PUTPOS
  129 
  130     putpos = putpos+1
				addl	$1, %eax
				movl	%eax, PUTPOS.95(%rip)
  131 %END
  132 
  133 %ROUTINE FAULT(%INTEGER K)
				ret
		.LVL10:
		.L6:
  134 !RECORD (FIRST) FAULT
  135 !NOT NECESSARILY CULPABLE IN PASS 0
  136     FSYM = K %IF FSYM = ' '
				cmpl	$32, 80(%r10)
				jne	.L8
				movl	%edi, 80(%r10)
  137 %END
  138 
		.L9:
		.L8:
  139 %ROUTINE PRINT(%INTEGER K)
				ret
		.LFE235:
		PRINT.5:
		.LVL15:
		.LFB236:
				pushq	%rbx
				movl	%edi, %esi
  140 !!    INTEGER(CODEPOS+CHARS) = K
  141     set INTEGER(CODEPOS+CHARS, K)
				movl	CHARS.99(%rip), %ebx
				movl	%ebx, %edi
		.LVL16:
				addl	CODEPOS.141(%rip), %edi
				call	SETINTEGER.8
		.LVL17:
  142     CHARS = CHARS+1
				addl	$1, %ebx
				movl	%ebx, CHARS.99(%rip)
  143 %END
  144 
  145 %ROUTINE PRINT WORD(%INTEGER V)
				popq	%rbx
				ret
		.LFE236:
		PRINTHIT.4:
		.LVL18:
		.LFB238:
				pushq	%rbx
				movl	%edi, %ebx
  146     %ROUTINE PRINT HIT(%INTEGER V)
  147         V = V&15+'0';  V = V+7 %IF V > '9'
				andl	$15, %edi
		.LVL19:
				leal	48(%rdi), %eax
		.LVL20:
				addl	$55, %edi
				cmpl	$57, %eax
				cmovg	%edi, %eax
		.LVL21:
		.L13:
  148         PRINT(V)
				movl	%eax, %edi
				call	PRINT.5
		.LVL22:
  149     %END
  150     %ROUTINE PRINT1(%INTEGER V)
		.LBB140:
		.LBB144:
  151         PRINT HIT(V>>4);  PRINT HIT(V)
				ret
		.LFE238:
		PUT.42:
		.LVL23:
		.LFB244:
				shrl	$12, %edi
		.LVL333:
				call	PRINTHIT.4
		.LVL334:
		.LBE140:
		.LBE139:
				call	PRINTHIT.4
		.LVL336:
				movl	%ebx, %edi
				shrl	$4, %edi
				call	PRINTHIT.4
		.LVL337:
				movl	%ebx, %edi
				call	PRINTHIT.4
		.LVL338:
  152     %END
  153     PRINT1(V>>8);  PRINT1(V)
		.LVL332:
		.LBB139:
		.LBI139:
				movl	%ebx, %edi
				shrl	$8, %edi
		.LVL335:
		.LBB142:
		.LBB141:
		.LBE141:
		.LBE142:
		.LBB143:
		.LBI143:
		.LBE144:
		.LBE143:
  154 %END
  155 
  156 %ROUTINE PRINT LOC
				popq	%rbx
		.LVL339:
				ret
		.LFE237:
		PRINTLOC.46:
		.LFB240:
				pushq	%rbx
				movq	%r10, %rbx
  157     PRINT WORD(LOC)
				movl	76(%r10), %edi
				call	PRINTWORD.2
		.LVL340:
  158     %IF LOCTYPE&RELMASK # 0 %THEN PRINT('''') %ELSE PRINT(' ')
				testb	$32, 72(%rbx)
				jne	.L395
		.LDL104:
				movl	$32, %edi
				call	PRINT.5
		.LVL341:
		.L396:
				movl	$39, %edi
				call	PRINT.5
		.LVL343:
				jmp	.L396
		.LFE240:
		PRINTLINE.47:
		.LFB242:
  159     PRINT(' ')
				movl	$32, %edi
				call	PRINT.5
		.LVL342:
  160 %END
  161 
  162 %ROUTINE DO NEWLINE
				subq	$8, %rsp
				popq	%rbx
				ret
		.L395:
  163     NEWLINE;  LINES = LINES+1
		.LBB71:
		.LBI71:
				movl	LINES.98(%rip), %eax
				addl	$1, %eax
				movl	%eax, LINES.98(%rip)
  164     NEWLINES(2) %AND LINES = 0 %IF LINES = 61
				cmpl	$61, %eax
				je	.L129
		.L127:
		.L126:
		.LVL97:
		.LBB73:
		.LBI73:
				movl	$0, LINES.98(%rip)
		
  165 %END
  166 
				jmp	.L126
		.LFE241:
		INTEGER.39:
		.LVL99:
		.LFB231:
  167 %ROUTINE PRINT LINE
				addq	$8, %rsp
				ret
		.L129:
				pushq	%rbx
				subq	$32, %rsp
				movq	%fs:40, %rax
		
				movq	%rax, 24(%rsp)
				xorl	%eax, %eax
				leaq	48(%rsp), %rax
				movq	%rax, 8(%rsp)
				movq	%r10, (%rsp)
  168    %ROUTINE PRINTIT(%INTEGER SUB)
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movl	%edi, %ebp
				movq	%r10, %rbx
  169    %OWNINTEGER MARKER=124;            !VERTICAL BAR
  170    %INTEGER P,Q,K
  171        %RETURN %IF CHARS = 0 %AND CHAR(PRINTPOS) = NL
				cmpl	$0, CHARS.99(%rip)
				jne	.L365
				movl	PRINTPOS.104(%rip), %edi
		.LVL277:
				call	CHAR.6
		.LVL278:
				cmpl	$10, %eax
				je	.L364
		.L365:
  172        PRINT SYMBOL(FSYM);  SPACE
		.LVL279:
		.LBB89:
		.LBI89:
				movq	(%rbx), %rax
		.LBB92:
		.LBB91:
		.LBB93:
		.LBI93:
  173        P = CODEPOS;  Q = P+CHARS
				movl	CODEPOS.141(%rip), %ebx
		.LVL282:
				movl	%ebx, %r12d
				addl	CHARS.99(%rip), %r12d
		.LVL283:
  174        PRINT SYMBOL(INTEGER(P)) %AND P=P+1 %WHILE P # Q
				cmpl	%r12d, %ebx
				je	.L369
		.L367:
				movl	%ebx, %edi
				call	INTEGER.39
		.LVL284:
		.LBB95:
		.LBI95:
				addl	$1, %ebx
		.LVL286:
		.LDL94:
				cmpl	%ebx, %r12d
				jne	.L367
		.L369:
		.LDL95:
  175        %RETURN %IF PRINTPOS = 0
				cmpl	$0, PRINTPOS.104(%rip)
				jne	.L377
		.LVL287:
		.L364:
		.LDL96:
  176        SPACES(17-CHARS)
		.LBB97:
		.LBI97:
				movl	$17, %edi
				subl	CHARS.99(%rip), %edi
		.LVL290:
		.LBB100:
		.LBB99:
  177        P = PRINTPOS;  Q = 0
				movl	PRINTPOS.104(%rip), %r12d
		.LVL292:
				movl	$0, %r13d
				jmp	.L370
		.LVL293:
		.L379:
  178        %CYCLE
  179           PRINT SYMBOL(MARKER) %IF P = FAULTPOS
		.LBB101:
		.LBI101:
				cmpl	%r12d, FAULTPOS.126(%rip)
				je	.L379
		.L371:
  180           K = CHAR(P);  K = SUB %IF P = PSEUDOLIM
				movl	%ebp, %ebx
				cmpl	%r12d, PSEUDOLIM.94(%rip)
				je	.L372
		.LVL301:
				movl	%r12d, %edi
				call	CHAR.6
		.LVL302:
				movl	%eax, %ebx
		.LVL303:
				jmp	.L372
		.LVL304:
		.L378:
  181           PRINT SYMBOL('''') %IF (K!!Q)&128 # 0
				xorl	%ebx, %r13d
		.LVL296:
				testb	$-128, %r13b
				jne	.L378
		.L373:
		.LBB105:
		.LBI105:
  182           %RETURN %IF K = NL
				cmpl	$10, %ebx
				je	.L364
		.LDL97:
  183           PRINT SYMBOL(K&127)
		.LVL297:
		.LBB103:
		.LBI103:
  184           P = P+1;  Q = K
				addl	$1, %r12d
		.LVL299:
				movl	%ebx, %r13d
		.LVL300:
		.L370:
  185        %REPEAT
  186    %END
  187     %RETURN %IF PASS = 0
				cmpl	$0, PASS.93(%rip)
				jne	.L408
		.L398:
		.LDL105:
  188     %UNLESS LIST < 0 %OR (PRINTPOS=0 %AND FSYM=' ' %AND LIST&1=0) %START
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
		.LVL288:
				popq	%r12
				popq	%r13
				ret
		.LVL289:
		.L377:
				movl	LIST.118(%rip), %eax
				testl	%eax, %eax
				js	.L400
				cmpl	$32, 80(%r10)
				jne	.L401
				andl	$1, %eax
				orl	PRINTPOS.104(%rip), %eax
				je	.L402
		.L401:
  189        NEWLINES(3) %IF LINES = 0
				cmpl	$0, LINES.98(%rip)
				je	.L410
		.L403:
		.LVL352:
		.LBB163:
		.LBI163:
		.LBB164:
				movl	$3, %edi
				call	_imp_newlines@PLT
		.LVL353:
				jmp	.L403
		.L411:
		.LBE164:
		.LBE163:
  190        PRINTIT(' ')
				movq	%rsp, %r10
				movl	$32, %edi
				call	PRINTIT.48
		.LVL344:
  191        DO NEWLINE
				call	DONEWLINE.15
		.LVL345:
		.L400:
  192     %FINISH
  193     %IF FSYM # ' ' %AND OUTDEV # 1 %START
				cmpl	$32, 80(%rbx)
				je	.L402
		.LBB155:
		.LBI155:
				cmpl	$1, _imp_OutStream(%rip)
				je	.L402
  194        SELECT OUTPUT(0)
		.LVL347:
		.LBB157:
		.LBI157:
  195        PRINTPOS = STARTPOS %IF PRINTPOS = 0
				cmpl	$0, PRINTPOS.104(%rip)
				jne	.L404
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PRINTPOS.104(%rip)
		.L404:
  196        PRINT LOC %IF CHARS = 0
				cmpl	$0, CHARS.99(%rip)
				je	.L411
		.L405:
				movq	%rbx, %r10
				call	PRINTLOC.46
		.LVL354:
				jmp	.L405
		.L409:
  197        PRINTIT(NL)
				movq	%rsp, %r10
				movl	$10, %edi
				call	PRINTIT.48
		.LVL349:
  198        NEWLINE
		.LBB159:
		.LBI159:
  199        SELECT OUTPUT(LIS)
		.LBB161:
		.LBI161:
  200     %FINISH
  201     FSYM = ' ';  PRINTPOS = 0;  CHARS = 0
				movl	$32, 80(%rbx)
				movl	$0, PRINTPOS.104(%rip)
		
				movl	$0, CHARS.99(%rip)
		
  202 %END
				jmp	.L398
		.L410:
  203 
  204 %ROUTINE PUT(%INTEGER V)
				movq	24(%rsp), %rax
				subq	%fs:40, %rax
		
				jne	.L409
				addq	$32, %rsp
				popq	%rbx
				ret
		.L408:
				movq	%r10, %rbx
				call	__stack_chk_fail@PLT
		.LVL355:
		.LFE242:
		PLANTVAL.1:
		.LFB249:
  205 !STORE 4-BIT ITEM IN BINARY RECORD
  206 %OWNINTEGER HOLD=0
  207     V = V&15
				andl	$15, %edi
		.LVL24:
				addl	%eax, %edi
		.LVL25:
				movl	%edi, HOLD.52(%rip)
  208     HOLD = HOLD<<4+V
				movl	HOLD.52(%rip), %eax
				sall	$4, %eax
  209     BINCOUNT = BINCOUNT+1
				movl	BINCOUNT.96(%rip), %eax
				addl	$1, %eax
				movl	%eax, BINCOUNT.96(%rip)
  210     %IF BINCOUNT&3 = 0 %START
				testb	$3, %al
				jne	.L14
  211        BREC(BINCOUNT>>2) = HOLD
				shrl	$2, %eax
				cltq
				leaq	-4+BREC.92(%rip), %rdx
				movl	%edi, (%rdx,%rax,4)
  212        CHECK = CHECK!!HOLD
				xorl	%edi, CHECK.91(%rip)
  213        HOLD = 0
				movl	$0, HOLD.52(%rip)
		
  214     %FINISH
  215 %END
  216 
		.L15:
		.L14:
  217 %ROUTINE PUT WORD(%INTEGER V)
				ret
		.LFE244:
		NEST.0:
		.LVL26:
		.LFB250:
				pushq	%rbx
				movl	%edi, %ebx
  218     %ROUTINE PUT1(%INTEGER V)
		.LBB130:
		.LBB134:
  219         PUT(V>>4);  PUT(V)
				shrl	$12, %edi
		.LVL324:
				call	PUT.42
		.LVL325:
		.LBE130:
		.LBE129:
				call	PUT.42
		.LVL327:
				movl	%ebx, %edi
				shrl	$4, %edi
				call	PUT.42
		.LVL328:
				movl	%ebx, %edi
				call	PUT.42
		.LVL329:
  220     %END
  221     PUT1(V>>8);  PUT1(V)
		.LVL323:
		.LBB129:
		.LBI129:
				movl	%ebx, %edi
				shrl	$8, %edi
		.LVL326:
		.LBB132:
		.LBB131:
		.LBE131:
		.LBE132:
		.LBB133:
		.LBI133:
		.LBE134:
		.LBE133:
  222 %END
  223 
  224 %ROUTINE OUTPUT RECORD
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				popq	%rbx
		.LVL330:
				ret
		.LFE245:
		PRINTWORD.2:
		.LVL331:
		.LFB237:
  225 %OWNINTEGER SEQ=0
  226 %INTEGER I
  227     %ROUTINE OUTPUT WORD(%INTEGER W)
				pushq	%rbx
				movl	%edi, %ebx
  228         PRINT CH(W>>8&255);  PRINT CH(W&255)
		.LVL271:
		.LBB85:
		.LBI85:
		.LBB87:
		.LBI87:
  229     %END
  230     PUT(0) %WHILE BINCOUNT # 208
				cmpl	$208, BINCOUNT.96(%rip)
		
				je	.L383
		.L381:
				movl	$0, %edi
				call	PUT.42
		.LVL306:
		.LDL98:
				cmpl	$208, BINCOUNT.96(%rip)
		
				jne	.L381
		.L383:
		.LDL99:
  231     SELECT OUTPUT(BIN)
				popq	%rbx
		.LVL275:
				ret
		.LFE248:
		PRINTIT.48:
		.LVL276:
		.LFB243:
		.LVL307:
		.LBB115:
		.LBI115:
  232     %CYCLE I = 1,1,10
  233        PRINT CH(0);                   !RUNOUT
		.LBB119:
		.LBI119:
  234     %REPEAT
  235     PRINT CH(16_F0);                  !HEADER CODE
		.LBB118:
		.LBB117:
				subl	$1, %ebx
		.LVL311:
				jne	.L382
		.LDL101:
		.LVL312:
		.LBB121:
		.LBI121:
  236     SEQ = SEQ-1
				movl	SEQ.51(%rip), %eax
				leal	-1(%rax), %edi
				movl	%edi, SEQ.51(%rip)
  237     OUTPUT WORD(SEQ);                 !SEQUENCE NUMBER
				call	OUTPUTWORD.44
		.LVL314:
  238     OUTPUT WORD(\(CHECK!!SEQ));       !CHECKSUM
				movl	CHECK.91(%rip), %edi
				xorl	SEQ.51(%rip), %edi
				notl	%edi
				call	OUTPUTWORD.44
		.LVL315:
  239     %CYCLE I = 1,1,52
  240        OUTPUT WORD(BREC(I))
				movl	(%rbx), %edi
				call	OUTPUTWORD.44
		.LVL317:
  241     %REPEAT
  242     BINCOUNT = 0;  CHECK = 0
				leaq	BREC.92(%rip), %rbx
				leaq	208(%rbx), %rbp
		.LVL316:
		.L384:
		.LDL102:
				addq	$4, %rbx
		.LVL318:
				cmpq	%rbp, %rbx
				jne	.L384
		.LDL103:
				movl	$0, BINCOUNT.96(%rip)
		
				movl	$0, CHECK.91(%rip)
		
  243     SELECT OUTPUT(LIS)
		.LVL319:
		.LBB123:
		.LBI123:
  244 %END
  245 
  246 %ROUTINE PLANT VAL
				addq	$8, %rsp
				popq	%rbx
		.LVL321:
				popq	%rbp
				ret
		.LFE247:
		PUTWORD.29:
		.LVL322:
		.LFB245:
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %rbx
  247 %INTEGER I,J
  248     TYPE = 0 %IF TYPE = SINGLE
				movl	68(%r10), %eax
				cmpl	$20480, %eax
				jne	.L413
				movl	$0, 68(%r10)
		
  249     I = 2;  I = 4 %IF TYPE&OPMASK # 0
		.LVL356:
				movl	$2, %ebp
				jmp	.L414
		.LVL357:
		.L413:
				testb	$-16, %ah
				je	.L430
				movl	$4, %ebp
		.L414:
		.LVL358:
				movl	$2, %ebp
				jmp	.L414
		.LVL361:
		.L433:
  250     %IF PASS > 0 %START
				cmpl	$0, PASS.93(%rip)
				jle	.L429
  251        OUTPUT RECORD %IF BINCOUNT+I+I >= 208
				movl	%ebp, %eax
				addl	BINCOUNT.96(%rip), %eax
				addl	%ebp, %eax
				cmpl	$207, %eax
				jg	.L433
		.L416:
				call	OUTPUTRECORD.43
		.LVL362:
				jmp	.L416
		.L417:
  252        %IF I = 4 %START
				cmpl	$4, %ebp
				je	.L417
		.LDL106:
  253           %IF TYPE&16_4000 = 0 %START
				testb	$64, 69(%rbx)
				je	.L420
		.LDL107:
  254              PUT(11);  J = TYPE!!OPMASK
				movl	$11, %edi
				call	PUT.42
		.LVL371:
				movl	68(%rbx), %r12d
				xorl	$61440, %r12d
		.LVL372:
  255              TYPE = RELMASK
				movl	%eax, 68(%rbx)
  256           %finish %ELSE %START
				movl	$32, %eax
				jmp	.L421
		.L434:
  257              PUT(10);  J = TYPE;  TYPE = 0
				movl	$10, %edi
				call	PUT.42
		.LVL363:
				movl	68(%rbx), %r12d
		.LVL364:
				movl	$0, %eax
		.L421:
  258           %FINISH
  259           PUT WORD(J)
				movl	%r12d, %edi
				call	PUTWORD.29
		.LVL365:
  260           PRINT LINE %IF CHARS # 0
				cmpl	$0, CHARS.99(%rip)
				jne	.L434
		.L422:
				movq	%rbx, %r10
				call	PRINTLINE.47
		.LVL373:
				jmp	.L422
		.LVL374:
		.L418:
  261           PRINT LOC
				movq	%rbx, %r10
				call	PRINTLOC.46
		.LVL366:
  262           PRINT WORD(J);  PRINT(' ')
				movl	%r12d, %edi
				call	PRINTWORD.2
		.LVL367:
				movl	$32, %edi
				call	PRINT.5
		.LVL368:
  263        %finish %ELSE %START
		.L423:
		.L426:
  264           %IF TYPE&RELMASK # 0 %THEN PUT(9) %ELSE PUT(8)
				testb	$32, 68(%rbx)
				je	.L418
				movl	$9, %edi
				call	PUT.42
		.LVL359:
				jmp	.L424
		.LVL360:
		.L430:
		.LDL108:
				movl	$8, %edi
				call	PUT.42
		.LVL375:
		.L424:
  265           %IF CHARS # 0 %THEN PRINT(' ') %ELSE PRINT LOC
				cmpl	$0, CHARS.99(%rip)
				jne	.L425
		.LDL109:
				movq	%rbx, %r10
				call	PRINTLOC.46
		.LVL376:
				jmp	.L426
		.L425:
				movl	$32, %edi
				call	PRINT.5
		.LVL377:
				jmp	.L426
		.L435:
  266        %FINISH
  267        PUT WORD(VAL);  PRINT WORD(VAL)
				movl	64(%rbx), %edi
				call	PUTWORD.29
		.LVL369:
				movl	64(%rbx), %edi
				call	PRINTWORD.2
		.LVL370:
  268        PRINT('''') %IF TYPE&RELMASK # 0
				testb	$32, 68(%rbx)
				jne	.L435
		.L427:
				movl	$39, %edi
				call	PRINT.5
		.LVL378:
		.LDL110:
  269        PRINT LINE %IF TYPE&RELMASK#0 %OR CHARS=15
				cmpl	$15, CHARS.99(%rip)
				jne	.L429
				jmp	.L428
		.L420:
				testb	$32, 68(%rbx)
				je	.L427
		.L428:
				movq	%rbx, %r10
				call	PRINTLINE.47
		.LVL379:
		.L415:
		.L429:
  270     %FINISH
  271     LOC = LOC+I
				addl	%ebp, 76(%rbx)
  272 %END
  273 
  274 %ROUTINE NEST(%INTEGER K)
				movl	%edi, %esi
				popq	%rbx
				popq	%rbp
		.LVL380:
				popq	%r12
				ret
		.LFE249:
		PLANTJUMP.28:
		.LFB254:
  275 !!    NP = NP-1;  %MONITOR 23 %IF NP = BP
  276     NP = NP-1;  !{}%signal 2,3 %IF NP = BP
				movl	NP.138(%rip), %eax
				leal	-1(%rax), %edi
		.LVL27:
				movl	%edi, NP.138(%rip)
  277 !!    INTEGER(NP) = K
  278     set INTEGER(NP, K)
				call	SETINTEGER.8
		.LVL28:
  279 %END
  280 
  281 %ROUTINE SET LAB(%INTEGER DEST)
				ret
		.LFE250:
		FORMINST.21:
		.LVL29:
		.LFB253:
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movl	%edi, %r12d
				movq	%r10, %rbx
  282 %INTEGER D
  283     D = DEST
		.LVL107:
				movl	%edi, %ebp
				jmp	.L137
		.LVL108:
		.L145:
  284     %CYCLE
  285        TYPE = INTEGER(NP)&16_FFF+DEFLIM; !DEST SLOT
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL110:
				andl	$4095, %eax
				addl	DEFLIM.135(%rip), %eax
				movl	%eax, 68(%rbx)
  286        NP = NP+1
				movl	NP.138(%rip), %eax
				leal	1(%rax), %edi
				movl	%edi, NP.138(%rip)
  287        VAL = INTEGER(NP);             !LOC OF JUMP
				call	INTEGER.39
		.LVL111:
  288        NP = NP+1
				addl	$1, NP.138(%rip)
  289        ATYPE = -1;  CREG = -1
				movl	$-1, 60(%rbx)
				movl	$-1, 56(%rbx)
  290        FLAG = 0;  FLAG = 2 %IF (D-VAL)>>1+PASS <= 16
				movl	PASS.93(%rip), %ecx
				movl	%ebp, %edx
				subl	%eax, %edx
				sarl	%edx
				addl	%ecx, %edx
				cmpl	$16, %edx
				setle	%dl
				movzbl	%dl, %edx
				addl	%edx, %edx
		.LDL28:
				movl	%edx, 52(%rbx)
  291        VAL = VAL-FLAG
				subl	%edx, %eax
				movl	%eax, 64(%rbx)
  292        %IF PASS = 0 %START
				testl	%ecx, %ecx
				je	.L138
		.LDL29:
  293 !!          D = D-FLAG;  INTEGER(TYPE) = D
  294           D = D-FLAG;  set INTEGER(TYPE, D)
				subl	%edx, %ebp
		.LVL114:
				movl	68(%rbx), %edi
				movl	%ebp, %esi
				call	SETINTEGER.8
		.LVL115:
  295           %IF FLAG # 0 %START
				cmpl	$0, 52(%rbx)
				jne	.L148
		.L139:
		.L142:
		.LDL30:
  296              LOC = LOC-2;  DEST = DEST-2
				subl	$2, 76(%rbx)
				subl	$2, %r12d
		.LVL119:
  297              %WHILE TYPE # ALMAX %CYCLE
				movl	68(%rbx), %edi
				cmpl	%edi, ALMAX.130(%rip)
				je	.L142
		.L141:
				movl	68(%rbx), %edi
				cmpl	%edi, ALMAX.130(%rip)
				jne	.L141
				jmp	.L142
		.L136:
  298 !!                TYPE = TYPE+1;  INTEGER(TYPE) = INTEGER(TYPE)-2
  299                 TYPE = TYPE+1;  set INTEGER(TYPE,  INTEGER(TYPE)-2)
				addl	$1, %edi
				movl	%edi, 68(%rbx)
				call	INTEGER.39
		.LVL120:
				leal	-2(%rax), %esi
				movl	68(%rbx), %edi
				call	SETINTEGER.8
		.LVL121:
  300              %REPEAT
		.LDL32:
  301           %FINISH
  302        %finish %ELSE %START
  303           FAULT('P') %IF INTEGER(TYPE) # D
				movl	68(%rbx), %edi
				call	INTEGER.39
		.LVL112:
				cmpl	%ebp, %eax
				je	.L142
				movq	%rbx, %r10
				movl	$80, %edi
				call	FAULT.45
		.LVL113:
				jmp	.L142
		.L138:
  304        %FINISH
  305        %RETURN %UNLESS INTEGER(NP)&16_1000 # 0
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL116:
				testb	$16, %ah
				je	.L136
		.LDL31:
  306        %IF INTEGER(NP)&16_2000 # 0 %START; !OR
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL117:
				testb	$32, %ah
				je	.L145
  307           D = VAL+4 %IF D = DEST
				cmpl	%ebp, %r12d
				jne	.L137
				movl	64(%rbx), %eax
				leal	4(%rax), %ebp
		.LVL118:
				jmp	.L137
		.L148:
  308        %finish %ELSE %START
  309           D = DEST
				movl	%r12d, %ebp
		.LVL109:
		.L137:
		.LDL27:
  310        %FINISH
  311     %REPEAT
  312 %END
  313 
  314 %ROUTINE ASSEMBLE
				popq	%rbx
				popq	%rbp
		.LVL122:
				popq	%r12
		.LVL123:
				ret
		.LFE251:
		LOOKUP.32:
		.LVL124:
		.LFB263:
				pushq	%r15
				pushq	%r14
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$72, %rsp
				movq	%r10, %rbx
				movq	%fs:40, %rax
		
				movq	%rax, 56(%rsp)
				xorl	%eax, %eax
				leaq	128(%rsp), %rax
		
				movq	%rax, 40(%rsp)
				movq	%r10, 16(%rsp)
  315 !   INTERDATA OP-CODES (+FORMATS)
  316 %OWNINTEGER LOAD=16_080F, LB=16_9303
  317 %OWNINTEGER ADD=16_0A0F, SUB=16_0B0F, AND=16_0407
  318 %OWNINTEGER OR=16_0607, XOR=16_0707
  319 %OWNINTEGER SLLS=16_7508, SRLS=16_7408, SLHL=16_0D04, SRHL=16_0C04
  320 %OWNINTEGER COMP=16_0907, CLB=16_9402
  321 %OWNINTEGER STORE=16_0002, STB=16_9202, AHM=16_2102
  322 %OWNINTEGER BT=16_0203, BF=16_0303
  323 !    FORMAT CODES
  324 %OWNINTEGER REGISTER=1, MEM=2, LIT=4, SHORT=8
  325 
  326 %OWNINTEGER ZQUERY=0
  327 %INTEGER OP,K,Q,LITVAL,NQ,TYPE1,VAL1,FREE
  328 %SWITCH ASS(-30:-1)
  329 
  330 %ROUTINE FORM INST(%INTEGER CODE)
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movl	%edi, %ebp
				movq	%r10, %rbx
  331 !    LS 4 BITS OF CODE DEFINE VALID FORMATS
  332 !    INTERDATA OP-CODES FOR DIFFERENT FORMATS
  333 !    ARE SYSTEMATICALLY RELATED
  334 !    SHORT=REGISTER+SINC, LIT=REGISTER+LINC, MEM=REGISTER+MINC
  335 %OWNINTEGER SINC=16_1C00, LINC=16_C000, MINC=16_4000
  336 %INTEGER OP
  337     OP = CODE&16_FFF0
				movl	%edi, %r12d
				andl	$65520, %r12d
		.LVL30:
  338     %IF TYPE = REG %START
				movq	(%r10), %rax
				cmpl	$128, 68(%rax)
				jne	.L18
  339        %IF CODE&REGISTER # 0 %START
				testb	$1, %dil
				je	.L33
		.LDL2:
  340           TYPE = SINGLE;  VAL = OP+VAL
				movl	$20480, 68(%rax)
				movq	(%r10), %rax
				addl	%r12d, 64(%rax)
  341           %RETURN
				jmp	.L17
		.L33:
  342        %FINISH
  343        TYPE = XMASK+VAL;  VAL = 0;    !COERCE TO INDEXED IMMEDIATE
				movl	64(%rax), %ecx
				leal	16(%rcx), %edx
				movl	%edx, 68(%rax)
				movq	(%r10), %rax
				movl	$0, 64(%rax)
		.L18:
  344     %FINISH
  345 !!    %IF TYPE=0 %AND !VAL!<=15 %AND CODE&SHORT#0 %START; !SHORT
  346     %IF TYPE=0 %AND |VAL|<=15 %AND CODE&SHORT#0 %START; !SHORT
				movq	(%rbx), %r10
				movl	68(%r10), %eax
				testl	%eax, %eax
				jne	.L21
				movl	64(%r10), %eax
		.LVL31:
		.LBB68:
		.LBI68:
  347        VAL = -VAL %AND OP = OP!!16_100 %IF VAL < 0
				testl	%eax, %eax
				jns	.L23
				negl	%eax
				movl	%eax, 64(%r10)
				xorl	$256, %r12d
		.LVL32:
		.L23:
  348        TYPE = SINGLE;  VAL = OP+SINC+VAL
				movq	(%rbx), %rax
				movl	$20480, 68(%rax)
				movq	(%rbx), %rax
				leal	7168(%r12), %edx
		
				addl	%edx, 64(%rax)
  349     %finish %ELSE %START
				jmp	.L17
		.L21:
  350        FAULT('R') %IF TYPE&31 = XMASK; !R0 AS INDEX
				andl	$31, %eax
				cmpl	$16, %eax
				jne	.L24
				movl	$82, %edi
		.LVL33:
				call	FAULT.45
		.LVL34:
		.L24:
  351        %IF TYPE&MEMMASK = 0 %START;   !IMMEDIATE
				movq	(%rbx), %r10
				testb	$64, 68(%r10)
				je	.L25
		.LDL3:
				movq	(%rbx), %r10
		.LVL38:
		.L25:
  352           FAULT('I') %IF CODE&LIT = 0
				movl	$73, %edi
				call	FAULT.45
		.LVL35:
				jmp	.L28
		.L34:
				testb	$4, %bpl
				je	.L35
		.L28:
  353           OP = OP+LINC
				leal	49152(%r12), %edx
		
		.LVL39:
  354        %finish %ELSE %START;                  !MEMORY
		.L29:
  355           FAULT('I') %IF CODE&MEM = 0
				testb	$2, %bpl
				je	.L34
		.L26:
				movl	$73, %edi
				call	FAULT.45
		.LVL36:
				jmp	.L26
		.LVL37:
		.L22:
  356           OP = OP+MINC
				leal	16384(%r12), %edx
		
				jmp	.L29
		.L35:
  357        %FINISH
  358        OP = OP!!OPMASK %IF TYPE&RELMASK # 0
				movq	(%rbx), %rcx
				movl	68(%rcx), %eax
				movl	%edx, %esi
				xorl	$61440, %esi
				testb	$32, %al
				cmovne	%esi, %edx
		.LVL40:
		.L30:
  359        TYPE = TYPE&15+OP
				andl	$15, %eax
				addl	%edx, %eax
				movl	%eax, 68(%rcx)
		.L20:
  360     %FINISH
  361 %END
  362 
		.LVL41:
		.L17:
  363 %ROUTINE PLANT JUMP
				popq	%rbx
				popq	%rbp
		.LVL42:
				popq	%r12
				ret
		.LFE253:
		RELEASE.20:
		.LFB258:
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movq	%r10, %rbx
  364 %INTEGER I,OP
  365     OP = BF;  COND=\COND %AND OP=BT %IF COND < 0
		.LVL381:
				movq	(%r10), %rdx
				movl	48(%rdx), %eax
				movl	$771, %ebp
				testl	%eax, %eax
				jns	.L437
				notl	%eax
				movl	%eax, 48(%rdx)
		.LVL382:
				movl	$515, %ebp
		.LVL383:
		.L437:
  366     %IF TYPE&(\UMASK) = LOCTYPE %START
				movq	(%rbx), %r10
				movl	68(%r10), %edx
				movl	%edx, %eax
				andb	$-3, %ah
				cmpl	72(%r10), %eax
				jne	.L445
  367        I = LOC>>1-VAL>>1
				movl	76(%r10), %eax
				shrl	%eax
				movl	64(%r10), %ecx
				shrl	%ecx
				subl	%ecx, %eax
		.LVL384:
  368 !!       FAULT('J') %AND I=0 %IF FLAG # 0 %AND !I! > 15
  369        FAULT('J') %AND I=0 %IF FLAG # 0 %AND |I| > 15
				cmpl	$0, 52(%r10)
				je	.L453
		.LVL385:
		.LBB165:
		.LBI165:
				cmpl	$15, %edx
				jg	.L454
		.LVL386:
		.L441:
		.LDL111:
				movl	$74, %edi
				call	FAULT.45
		.LVL395:
  370 !!       %IF !I! <= 15 %START
  371        %IF |I| <= 15 %START
		.LBB167:
		.LBI167:
				cmpl	$15, %ecx
				jg	.L445
		.LVL392:
		.LBB170:
  372           %IF TYPE&UMASK = 0 %OR FLAG # 0 %START
				testb	$2, %dh
				je	.L441
		.L446:
		.LDL112:
				movq	(%rbx), %r10
				movl	68(%r10), %eax
				andl	$512, %eax
				je	.L441
				cmpl	$0, 52(%r10)
				je	.L446
				movl	$0, %eax
				jmp	.L441
		.LFE254:
		SETJUMP.26:
		.LVL396:
		.LFB255:
  373              OP = OP<<1+2;            !0408, 0608
				leal	2(%rbp,%rbp), %ebp
		.LVL387:
  374              TYPE = 0;  VAL = I
				movl	$0, 68(%r10)
		
				movq	(%rbx), %rdx
				movl	%eax, 64(%rdx)
  375           %finish %ELSE %START
		.L438:
		.L443:
		.L444:
		.L445:
  376              FAULT('S') %IF LIST >= 0 %AND LIST&8 # 0
				movl	LIST.118(%rip), %eax
				testl	%eax, %eax
				js	.L445
				testb	$8, %al
				je	.L445
				movl	$83, %edi
				call	FAULT.45
		.LVL393:
				jmp	.L445
		.LVL394:
		.L454:
  377           %FINISH
  378        %FINISH
  379     %FINISH
  380     FORM INST(COND<<4+OP)
				movq	(%rbx), %rax
				movl	48(%rax), %edi
				sall	$4, %edi
				addl	%ebp, %edi
				movq	%rbx, %r10
				call	FORMINST.21
		.LVL388:
  381     PLANT VAL
				movq	(%rbx), %r10
				call	PLANTVAL.1
		.LVL389:
  382     COND = 0
				movq	(%rbx), %rax
				movl	$0, 48(%rax)
  383 %END
  384 
  385 %ROUTINE SET JUMP(%INTEGER CASE)
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
		.LVL390:
				ret
		.LVL391:
		.L453:
				pushq	%r15
				pushq	%r14
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movl	%edi, %r12d
				movq	%r10, %rbx
  386 %INTEGER THOLD,VHOLD,FHOLD
  387 !!    ALMAX = ALMAX+1;  %MONITOR 22 %IF ALMAX = LABMIN
  388     ALMAX = ALMAX+1;  !{}%signal 2,2 %IF ALMAX = LABMIN
				movl	ALMAX.130(%rip), %eax
				leal	1(%rax), %ebp
				movl	%ebp, ALMAX.130(%rip)
  389     NEST(LOC);  NEST(ALMAX-DEFLIM+CASE)
				movq	(%r10), %rax
				movl	76(%rax), %edi
		.LVL397:
				call	NEST.0
		.LVL398:
				movl	%ebp, %edi
				subl	DEFLIM.135(%rip), %edi
				addl	%r12d, %edi
				call	NEST.0
		.LVL399:
  390     THOLD = TYPE;  VHOLD = VAL;  FHOLD = FLAG
				movq	(%rbx), %rax
				movl	68(%rax), %r14d
		.LVL400:
				movl	64(%rax), %r13d
		.LVL401:
				movl	52(%rax), %r12d
		.LVL402:
  391     TYPE = LOCTYPE;  VAL = INTEGER(ALMAX);  FLAG = 0
				movl	72(%rax), %edx
				movl	%edx, 68(%rax)
				movq	(%rbx), %r15
				movl	%ebp, %edi
				call	INTEGER.39
		.LVL403:
				movl	%eax, 64(%r15)
				movq	(%rbx), %rax
				movl	$0, 52(%rax)
  392     TYPE = TYPE+UMASK %IF PASS = 0
				cmpl	$0, PASS.93(%rip)
				jne	.L456
				movq	(%rbx), %rax
				addl	$512, 68(%rax)
		.L456:
  393     COND = \COND
				movq	(%rbx), %rax
				notl	48(%rax)
  394     PLANT JUMP
				movq	%rbx, %r10
				call	PLANTJUMP.28
		.LVL404:
  395     TYPE = THOLD;  VAL = VHOLD;  FLAG = FHOLD
				movq	(%rbx), %rax
				movl	%r14d, 68(%rax)
				movq	(%rbx), %rax
				movl	%r13d, 64(%rax)
				movq	(%rbx), %rax
				movl	%r12d, 52(%rax)
  396 %END
  397 
  398 %ROUTINE PLANT INST(%INTEGER CODE)
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
				popq	%r12
		.LVL405:
				popq	%r13
		.LVL406:
				popq	%r14
		.LVL407:
				popq	%r15
				ret
		.LFE255:
		PLANTINST.25:
		.LVL408:
		.LFB256:
				pushq	%rbx
				movq	%r10, %rbx
  399     FORM INST(CODE)
				call	FORMINST.21
		.LVL409:
  400     SET JUMP(16_1000) %IF COND # 0
				movq	(%rbx), %rax
				cmpl	$0, 48(%rax)
				jne	.L461
		.L459:
				movq	%rbx, %r10
				movl	$4096, %edi
				call	SETJUMP.26
		.LVL411:
				jmp	.L459
		.LFE256:
		LOADREG.24:
		.LVL412:
		.LFB257:
  401     PLANT VAL
				movq	(%rbx), %r10
				call	PLANTVAL.1
		.LVL410:
  402 %END
  403 
  404 %ROUTINE LOAD REG(%INTEGER R)
				popq	%rbx
				ret
		.L461:
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movl	%edi, %ebp
				movq	%r10, %rbx
  405 %INTEGER OP
  406     %IF ATYPE = TYPE %AND AVAL = VAL %START
				movq	(%r10), %rax
				movl	68(%rax), %edx
				cmpl	%edx, 60(%rax)
				jne	.L463
				movl	64(%rax), %ecx
				cmpl	%ecx, 44(%rax)
				jne	.L463
  407        TYPE = REG;  VAL = ACC
				movl	$128, 68(%rax)
				movq	(%r10), %rax
				movl	40(%rax), %edx
				movl	%edx, 64(%rax)
  408        %RETURN %IF R = ACC
				movq	(%r10), %rax
				cmpl	%edi, 40(%rax)
				jne	.L464
				jmp	.L462
		.L463:
		.LDL113:
  409     %FINISH
  410     ATYPE = TYPE %AND AVAL = VAL %IF R = ACC
				cmpl	40(%rax), %ebp
				jne	.L464
				movl	%edx, 60(%rax)
				movq	(%rbx), %rax
				movl	64(%rax), %edx
				movl	%edx, 44(%rax)
		.L464:
  411     ATYPE = -1 %IF (ATYPE=REG %AND AVAL=R) %OR ATYPE&15=R#0
				movq	(%rbx), %rdx
				movl	60(%rdx), %eax
				cmpl	$128, %eax
				jne	.L466
				cmpl	44(%rdx), %ebp
				je	.L467
		.L466:
				andl	$15, %eax
				cmpl	%ebp, %eax
				jne	.L468
				testl	%ebp, %ebp
				je	.L468
		.L467:
				movl	$-1, 60(%rdx)
		.L468:
  412     %IF TYPE&BMASK = 0 %START
				movq	(%rbx), %rdx
				movl	68(%rdx), %eax
				testb	$1, %ah
				je	.L469
		.LDL114:
  413        OP = LOAD
				movl	$2063, %eax
		.LVL415:
		.L472:
  414        OP = ADD %AND TYPE = 0 %IF TYPE!!XMASK = R # 0
				xorl	$16, %eax
				cmpl	%ebp, %eax
				jne	.L475
				testl	%ebp, %ebp
				jne	.L478
		.L475:
				movl	$0, 68(%rdx)
				movl	$2575, %eax
				jmp	.L472
		.LFE257:
		LOADTEMP.22:
		.LFB259:
  415        CREG = R;  CTYPE = 0;  CVAL = 0
				movq	(%rbx), %rdx
				movl	%ebp, 56(%rdx)
				movq	(%rbx), %rdx
				movl	$0, 36(%rdx)
				movq	(%rbx), %rdx
				movl	$0, 32(%rdx)
  416     %finish %ELSE %START
		.L470:
		.LVL416:
		.L473:
  417        OP = LB
		.LVL413:
				movl	$37635, %eax
				movl	$37635, %eax
				jmp	.L473
		.LVL414:
		.L469:
  418        CREG = -1 %IF CREG = R
				cmpl	56(%rdx), %ebp
				jne	.L473
				movl	$-1, 56(%rdx)
  419     %FINISH
  420     PLANT INST(R<<4+OP)
				movl	%ebp, %edi
		.LVL417:
				sall	$4, %edi
				addl	%eax, %edi
				movq	%rbx, %r10
				call	PLANTINST.25
		.LVL418:
  421     TYPE = REG;  VAL = R
				movq	(%rbx), %rax
				movl	$128, 68(%rax)
				movq	(%rbx), %rax
				movl	%ebp, 64(%rax)
  422 %END
  423 
		.LVL419:
		.L462:
  424 %ROUTINE RELEASE
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
		.LVL420:
				ret
		.LVL421:
		.L478:
  425 %INTEGER I
  426     %RETURN %IF TYPE&REGXMASK = 0
				movq	(%r10), %rax
				movl	68(%rax), %ecx
				testb	$-112, %cl
				jne	.L43
		.L37:
		.L41:
		.L36:
		.LDL4:
  427     I = TYPE&15;  I = VAL %IF I = 0
		.LVL43:
				andl	$15, %ecx
		.LVL44:
				jne	.L38
				movl	64(%rax), %ecx
		.LVL45:
		.L38:
  428     %IF I = DREG %START
				cmpl	28(%rax), %ecx
				je	.L39
		.LDL5:
  429        DUSE = DUSE-1
				subl	$1, 24(%rax)
  430     %finish %ELSE %START
				ret
		.LFE258:
		SWOP.23:
		.LFB260:
  431        I = 1<<I
				movl	$1, %eax
				sall	%cl, %eax
		.LVL46:
  432        FREE = FREE!I %IF TEMPS&I # 0
				movl	%eax, %edx
				andl	TEMPS.97(%rip), %edx
				je	.L44
				orl	%eax, 16(%r10)
  433     %FINISH
  434 %END
  435 
				ret
		.L44:
				ret
		.LVL47:
		.L39:
  436 %ROUTINE LOAD TEMP
				ret
		.L43:
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movq	%r10, %rbp
  437 %INTEGER I,J
  438     RELEASE
				call	RELEASE.20
		.LVL422:
  439     %IF DREG >= ZQUERY %AND DUSE = 0 %START
				movl	ZQUERY.66(%rip), %eax
				movq	0(%rbp), %r10
				movl	28(%r10), %edx
				cmpl	%edx, %eax
				jg	.L480
				cmpl	$0, 24(%r10)
				jne	.L480
  440        I = DREG;  DUSE = 1
		.LVL423:
				movl	$1, 24(%r10)
		
				movl	%edx, %edi
  441     %finish %ELSE %START
				jmp	.L481
		.LVL424:
		.L480:
  442        J = 1+ZQUERY
				leal	1(%rax), %ebx
		.LVL425:
  443        %CYCLE I = ZQUERY,1,15
				leal	-1(%rax), %edi
		.LVL426:
  444           ->OK %IF FREE&J # 0 %AND I # DREG
				movl	16(%rbp), %eax
				jmp	.L487
		.L486:
				testl	%ebx, %eax
				je	.L485
				cmpl	%edi, %edx
				je	.L485
				jmp	.L483
		.LFE259:
				.section	.rodata.str1.8,"aMS",@progbits,1
				.align 8
		.LC0:
				.string	"regression-compile-tmp/hal70.imp"
		
		
		
		
				.align 8
		.LC1:
				.string	"%%SWITCH index ASS(%d) not in range -30:-1 at %s:%d\n"
		
		
		
		
				.align 8
		.LC2:
				.string	"%%SWITCH LABEL NOT SET - sw1_ASS(%d): at line %s:%d"
		
		
		
		
		ASSEMBLE.18:
		.LFB252:
  445           J = J<<1
				addl	%ebx, %ebx
		.LVL433:
  446        %REPEAT
				cmpl	$16, %eax
				je	.L486
		.LDL115:
		.LDL116:
				cmpl	$15, %edi
				je	.L486
		.L487:
  447        FAULT('R')
				movl	$82, %edi
		.LVL427:
				call	FAULT.45
		.LVL428:
				movl	$15, %edi
		.LVL429:
		.L483:
				addl	$1, %edi
		.LVL434:
  448 OK:    FREE = FREE-J
				subl	%ebx, 16(%rbp)
		.LVL430:
		.L481:
  449     %FINISH
  450     LOAD REG(I)
				movq	%rbp, %r10
				call	LOADREG.24
		.LVL431:
  451 %END
  452 
  453 %ROUTINE SWOP
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
				ret
		.LVL432:
				.p2align 4
		.L485:
  454 %INTEGER K
  455     K = TYPE1;  TYPE1 = TYPE;  TYPE = K
				movl	12(%r10), %edx
		.LVL48:
				movq	(%r10), %rax
				movl	68(%rax), %ecx
				movl	%ecx, 12(%r10)
				movl	%edx, 68(%rax)
  456     K = VAL1;  VAL1 = VAL;  VAL = K
				movl	8(%r10), %edx
		.LVL49:
				movq	(%r10), %rax
				movl	64(%rax), %ecx
				movl	%ecx, 8(%r10)
				movl	%edx, 64(%rax)
  457 %END
  458 
  459 %ROUTINE PROGREF
				ret
		.LFE260:
		PROGREF.27:
		.LFB261:
  460     %IF TYPE&RELUXMASK = XMASK %AND VAL = 0 %START
				movq	(%r10), %rdx
				movl	68(%rdx), %eax
				movl	%eax, %ecx
				andl	$560, %ecx
				cmpl	$16, %ecx
				jne	.L47
				cmpl	$0, 64(%rdx)
				jne	.L47
  461        VAL = TYPE&15;  TYPE = REG
				andl	$15, %eax
				movl	%eax, 64(%rdx)
				movq	(%r10), %rax
				movl	$128, 68(%rax)
		.L47:
  462     %FINISH
  463     TYPE = TYPE!MEMMASK %IF TYPE # REG
				movq	(%r10), %rdx
				movl	68(%rdx), %eax
				cmpl	$128, %eax
				je	.L46
				orl	$64, %eax
				movl	%eax, 68(%rdx)
  464 %END
  465 
		.L48:
		.L46:
  466     Q = QSTART
				ret
		.LFE261:
		TEMP.19:
		.LFB262:
				movl	QSTART.124(%rip), %r14d
		.L490:
		.LDL117:
		.LDL118:
		.LVL435:
  467 NEW:NQ = QSTART;  FREE = TEMPS
				movl	QSTART.124(%rip), %r13d
		.LVL436:
				movl	TEMPS.97(%rip), %eax
				movl	%eax, 32(%rsp)
  468     TYPE = INTEGER(Q);  Q = Q+1
				movl	%r14d, %edi
				call	INTEGER.39
		.LVL437:
				movl	%eax, 68(%rbx)
		.LVL438:
				leal	1(%r14), %edi
		.LVL439:
  469     VAL = INTEGER(Q);  Q = Q+1
				call	INTEGER.39
		.LVL440:
				movl	%eax, 64(%rbx)
				leal	2(%r14), %r12d
		.LVL441:
  470 
		.LBB69:
				movl	%eax, %edx
				negl	%edx
				cmovs	%eax, %edx
		.LBE69:
		.LBE68:
				cmpl	$15, %edx
				jg	.L22
				testb	$8, %bpl
				je	.L22
		.LBB166:
				movl	%eax, %edx
				negl	%edx
				cmovs	%eax, %edx
		.LBE166:
		.LBE165:
		.LBB168:
				movl	%eax, %ecx
				negl	%ecx
				cmovs	%eax, %ecx
		.LBE168:
		.LBE167:
		.LBB169:
		.LBE169:
		.LBE170:
  471 GET:%CYCLE
  472        %RETURN %IF Q = QLIM
				cmpl	QLIM.123(%rip), %r12d
				jne	.L491
				jmp	.L489
		.LVL442:
		.L640:
				cmpl	%r12d, QLIM.123(%rip)
				je	.L489
		.L491:
		.LDL120:
  473        K = INTEGER(Q);  Q = Q+1
				movl	%r14d, %r12d
		.LVL460:
		.L494:
				movl	%r12d, %edi
				call	INTEGER.39
		.LVL461:
				movl	%eax, %ebp
		.LVL462:
				leal	1(%r12), %r14d
		.LVL463:
				movl	%r14d, %r12d
				movl	%r14d, %r12d
  474        ->ASS(K) %IF K < 0
		.LDL119:
				testl	%eax, %eax
				jns	.L640
				cmpl	$-30, %eax
				jb	.L495
				cltq
		.LVL464:
				leaq	sw1_ASS.80(%rip), %rcx
				jmp	*240(%rcx,%rax,8)
		.LVL465:
		.L612:
  475 !!       INTEGER(NQ) = TYPE1;  INTEGER(NQ+1) = VAL1
  476        set INTEGER(NQ, TYPE1);  set INTEGER(NQ+1, VAL1)
				movl	%r15d, %esi
				movl	%r13d, %edi
				call	SETINTEGER.8
		.LVL443:
				leal	1(%r13), %edi
				movl	4(%rsp), %esi
				call	SETINTEGER.8
		.LVL444:
				testl	%r9d, %r9d
				movl	$478, %eax
		.LVL449:
				cmove	%eax, %r9d
				testq	%rax, %rax
		.LVL450:
		.LBB171:
		.LBI171:
  477        NQ = NQ+2
				addl	$2, %r13d
		.LVL445:
				movq	_imp_current_file(%rip), %rax
  478        TYPE1 = TYPE;  VAL1 = VAL
				movl	68(%rbx), %r15d
				movl	64(%rbx), %eax
				movl	%eax, 4(%rsp)
				movl	_imp_current_line(%rip), %r9d
  479        TYPE = K;  VAL = INTEGER(Q);  Q = Q+1
				movl	%ebp, 68(%rbx)
				movl	%r14d, %edi
				call	INTEGER.39
		.LVL446:
				movl	%eax, 64(%rbx)
				addl	$2, %r12d
		.LVL447:
				movl	$1, %edi
				call	exit@PLT
		.LVL452:
		.L620:
  480     %REPEAT
				jmp	.L494
		.LVL448:
		.L495:
  481 
  482 %PREDICATE TEMP
  483     %FALSE %IF TYPE1 # REG
				movl	$0, %eax
		.L50:
				cmpl	$128, 12(%r10)
		
				je	.L53
		.L49:
		.LDL6:
  484     %IF VAL1 = DREG %START
				movl	8(%r10), %ecx
				movq	(%r10), %rax
				cmpl	28(%rax), %ecx
				je	.L51
		.LDL7:
  485        %FALSE %IF DUSE # 1
				cmpl	$1, 24(%rax)
				sete	%al
				movzbl	%al, %eax
				ret
		.LFE262:
		GETSYM.7:
		.LFB265:
  486     %finish %ELSE %START
  487        %FALSE %IF 1<<VAL1&TEMPS = 0
				movl	TEMPS.97(%rip), %eax
				sarl	%cl, %eax
				andl	$1, %eax
				ret
		.L51:
  488     %FINISH
  489     %TRUE
  490 %END
  491 
				ret
		.L53:
  492 NOP: K = 0;                           !NOT SYMMETRIC
				movl	$0, %ebp
				movl	$0, %ebp
		.LVL503:
				movl	$0, %ebp
		.LVL507:
  493 BOP:%IF MODE <= 0 %OR (TYPE = 0 %AND TYPE1 = 0) %START
				movl	68(%rbx), %r12d
				cmpl	$0, 20(%rbx)
				jle	.L499
				movl	68(%rbx), %r12d
				testl	%r12d, %r12d
				jne	.L500
		.LVL491:
		.L616:
				testl	%r15d, %r15d
				je	.L502
		.L492:
				cmpl	$0, 20(%rbx)
				jle	.L614
				movl	68(%rbx), %r12d
		.LVL592:
		.L500:
				movl	$0, %ebp
				cmpl	$0, 20(%rbx)
				jg	.L616
				jmp	.L502
		.LVL597:
		.L622:
  494        FAULT('A') %IF TYPE # 0
				cmpl	$0, 68(%rbx)
				je	.L502
		.LVL454:
		.L614:
				movq	%rbx, %r10
				movl	$65, %edi
				call	FAULT.45
		.LVL455:
		.L502:
  495        TYPE = TYPE1;  VAL = LITVAL
				movl	%r15d, 68(%rbx)
				movl	12(%rsp), %eax
				movl	%eax, 64(%rbx)
  496     %finish %ELSE %START
		.L503:
		.L514:
		.LVL456:
		.L515:
  497        %IF %NOT TEMP %OR (TYPE=REG %AND VAL=DREG %AND DUSE=1 %AND K#0) %START
		.LDL121:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	TEMP.19
		.LVL492:
				testl	%eax, %eax
				jne	.L612
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	TEMP.19
		.LVL593:
				testl	%eax, %eax
				jne	.L612
				cmpl	$128, %r12d
				jne	.L509
				movl	28(%rbx), %eax
				cmpl	%eax, 64(%rbx)
				jne	.L508
				cmpl	$1, 24(%rbx)
				jne	.L508
				testl	%ebp, %ebp
				je	.L508
  498           SWOP
				leaq	16(%rsp), %r10
				call	SWOP.23
		.LVL466:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
				leaq	16(%rsp), %r10
				call	SWOP.23
		.LVL594:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
  499           %IF K = 0 %OR %NOT TEMP %START
				testl	%ebp, %ebp
				je	.L505
		.L506:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	TEMP.19
		.LVL467:
				testl	%eax, %eax
				jne	.L509
		.L505:
				jmp	.L506
		.LVL595:
		.L621:
  500              LOAD TEMP;  SWOP
		.LBB80:
				movq	%r12, %rdi
				call	_imp_readsymbol@PLT
		.LVL237:
		.LBE80:
		.LBE79:
		.LBB82:
				movq	%r12, %rdi
				call	_imp_readsymbol@PLT
		.LVL241:
		.LBE82:
		.LBE81:
		.LBB84:
				movq	%r12, %rdi
				call	_imp_readsymbol@PLT
		.LVL247:
		.LBE84:
		.LBE83:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %rbp
		.LVL468:
				movq	%rbp, %r10
				call	LOADTEMP.22
		.LVL469:
				movq	%rbp, %r10
				call	SWOP.23
		.LVL470:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
		.L507:
		.LVL471:
		.L509:
  501           %FINISH
  502        %FINISH
  503        LOAD TEMP %IF TYPE&BMASK # 0 %OR (OP&MEM=0 %AND TYPE&MEMMASK#0)
				movl	68(%rbx), %r12d
				testl	$256, %r12d
				je	.L508
		.L510:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	LOADTEMP.22
		.LVL472:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
		.L511:
				movl	68(%rbx), %r12d
		.LVL493:
		.L508:
				testb	$2, 8(%rsp)
				jne	.L511
				testb	$64, %r12b
				jne	.L510
				jmp	.L511
		.LVL494:
		.L525:
				endbr64
  504        RELEASE
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r12
				movq	%r12, %r10
				call	RELEASE.20
		.LVL473:
				movl	24(%rsp), %ebp
  505        PLANT INST(VAL1<<4+OP)
		.LBB90:
		.LBE90:
		.LBE89:
				movsbl	80(%rax), %edi
				call	_imp_printsymbol@PLT
		.LVL280:
		.LBE91:
		.LBE92:
		.LBB96:
				movsbl	%al, %edi
				call	_imp_printsymbol@PLT
		.LVL285:
		.LBE96:
		.LBE95:
		.LBB102:
				movl	$124, %edi
				call	_imp_printsymbol@PLT
		.LVL294:
				jmp	.L371
		.L372:
		.LVL295:
		.LBE102:
		.LBE101:
		.LBB104:
				movl	%ebx, %edi
				andl	$127, %edi
				call	_imp_printsymbol@PLT
		.LVL298:
		.LBE104:
		.LBE103:
		.LBB106:
				movl	$39, %edi
				call	_imp_printsymbol@PLT
		.LVL305:
				jmp	.L373
		.LBE106:
		.LBE105:
		.LFE243:
		OUTPUTRECORD.43:
		.LFB247:
				movl	%ebp, %edi
				sall	$4, %edi
				movl	8(%rsp), %eax
				addl	%eax, %edi
				movq	%r12, %r10
				call	PLANTINST.25
		.LVL474:
  506        TYPE = REG;  VAL = VAL1
		.LBB86:
				movsbl	%bh, %edi
		.LVL272:
				call	_imp_printch@PLT
		.LVL273:
		.LBE86:
		.LBE85:
		.LBB88:
				movsbl	%bl, %edi
				call	_imp_printch@PLT
		.LVL274:
		.LBE88:
		.LBE87:
		.LBB120:
				movl	$0, %edi
				call	_imp_printch@PLT
		.LVL310:
		.LBE120:
		.LBE119:
		.LBB122:
				movl	$-16, %edi
				call	_imp_printch@PLT
		.LVL313:
		.LBE122:
		.LBE121:
				movl	$128, 68(%rbx)
				movl	%ebp, 64(%rbx)
  507        CREG = VAL;  CTYPE = 0;  CVAL = 0
		.LBB76:
				subq	$256, %rsp
				movdqa	256(%rsp), %xmm0
		
				movups	%xmm0, (%rsp)
				movdqa	272(%rsp), %xmm1
		
				movups	%xmm1, 16(%rsp)
				movdqa	288(%rsp), %xmm2
		
				movups	%xmm2, 32(%rsp)
				movdqa	304(%rsp), %xmm3
		
				movups	%xmm3, 48(%rsp)
				movdqa	320(%rsp), %xmm4
		
				movups	%xmm4, 64(%rsp)
				movdqa	336(%rsp), %xmm5
		
				movups	%xmm5, 80(%rsp)
				movdqa	352(%rsp), %xmm6
		
				movups	%xmm6, 96(%rsp)
				movdqa	368(%rsp), %xmm7
		
				movups	%xmm7, 112(%rsp)
				movdqa	384(%rsp), %xmm0
		
				movups	%xmm0, 128(%rsp)
		
				movdqa	400(%rsp), %xmm1
		
				movups	%xmm1, 144(%rsp)
		
				movdqa	416(%rsp), %xmm2
		
				movups	%xmm2, 160(%rsp)
		
				movdqa	432(%rsp), %xmm3
		
				movups	%xmm3, 176(%rsp)
		
				movdqa	448(%rsp), %xmm4
		
				movups	%xmm4, 192(%rsp)
		
				movdqa	464(%rsp), %xmm5
		
				movups	%xmm5, 208(%rsp)
		
				movdqa	480(%rsp), %xmm6
		
				movups	%xmm6, 224(%rsp)
		
				movq	$0, 240(%rsp)
		
		
				movq	$0, 248(%rsp)
		
		
				call	_imp_printstring@PLT
		.LVL101:
		.LBE76:
		.LBE75:
				movl	%ebp, 56(%rbx)
				movl	$0, 36(%rbx)
				movl	$0, 32(%rbx)
  508        ATYPE = -1 %IF ACC = VAL %OR ATYPE&15 = VAL # 0
				cmpl	%ebp, 40(%rbx)
				je	.L512
				movl	60(%rbx), %eax
				movl	%eax, %edx
				andl	$15, %edx
				cmpl	%ebp, %edx
				jne	.L513
				testl	%ebp, %ebp
				jne	.L512
		.L513:
				movl	$-1, 60(%rbx)
  509        ATYPE = -1 %IF ATYPE = REG %AND AVAL = VAL
				cmpl	$128, %eax
				jne	.L515
				cmpl	%ebp, 44(%rbx)
				jne	.L515
				movl	$-1, 60(%rbx)
				jmp	.L515
		.L512:
				jmp	.L515
		.LVL475:
		.L516:
				endbr64
  510     %FINISH
  511 
  512 POP:NQ = NQ-2
				leal	-2(%r13), %ebp
		.LVL457:
				movl	%ebp, %r13d
  513     TYPE1 = INTEGER(NQ);  VAL1 = INTEGER(NQ+1)
				movl	%ebp, %edi
				call	INTEGER.39
		.LVL458:
				movl	%eax, %r15d
				leal	-1(%r13), %edi
				call	INTEGER.39
		.LVL459:
				movl	%eax, 4(%rsp)
  514     ->GET
  515 
  516 ASS(-2):
  517     OP = SUB
		.LVL476:
				movl	$2831, 8(%rsp)
		
				jmp	.L500
		.LVL478:
		.L517:
  518     ->NOP %IF MODE > 0 %AND TYPE # 0
				cmpl	$0, 20(%rbx)
				jle	.L517
				cmpl	$0, 68(%rbx)
				je	.L518
		.LVL477:
  519     TYPE1 = 0 %AND TYPE = 0 %IF MODE <= 0 %AND TYPE1 = TYPE
				cmpl	%r15d, 68(%rbx)
				jne	.L518
				movl	$0, 68(%rbx)
				movl	$0, %r15d
		.L518:
  520     VAL = -VAL
				negl	64(%rbx)
		.LVL479:
		.L520:
				endbr64
  521 ASS(-1):
  522     OP = ADD;  LITVAL = VAL1+VAL
				movl	$2575, 8(%rsp)
		
				jmp	.L498
		.LVL453:
		.L499:
		.LVL480:
				movl	4(%rsp), %eax
				movl	%eax, %edx
				addl	64(%rbx), %edx
				movl	%edx, 12(%rsp)
		.LVL481:
				movl	$2575, 8(%rsp)
		
		.LVL591:
		.L521:
  523     ->BOP %UNLESS TYPE = 0
				cmpl	$0, 68(%rbx)
				jne	.L619
		.LDL122:
  524     %IF TYPE1&MEMMASK # 0 %AND MODE > 0 %START
				testb	$64, %r15b
				je	.L522
				cmpl	$0, 20(%rbx)
				jle	.L522
  525        SWOP;  LOAD TEMP;  SWOP
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r12
				movq	%r12, %r10
				call	SWOP.23
		.LVL482:
				movq	%r12, %r10
				call	LOADTEMP.22
		.LVL483:
				movq	%r12, %r10
				call	SWOP.23
		.LVL484:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
		.L522:
  526     %FINISH
  527     %IF TYPE1 = REG %START
				cmpl	$128, %r15d
				jne	.L523
  528        ->BOP %IF VAL1 = 0
				movl	4(%rsp), %eax
				testl	%eax, %eax
				je	.L620
		.LDL123:
  529        TYPE1 = XMASK+VAL1;  LITVAL = VAL
				addl	$16, %eax
				movl	%eax, %r15d
		.LVL485:
				movl	64(%rbx), %eax
				movl	%eax, 12(%rsp)
		.LVL486:
		.L523:
  530     %FINISH
  531     TYPE = TYPE1;  VAL = LITVAL
				movl	%r15d, 68(%rbx)
				movl	12(%rsp), %eax
				movl	%eax, 64(%rbx)
  532     ->POP
		.LBB156:
				leaq	__PRETTY_FUNCTION__.50(%rip), %rdi
				call	check_outstream@PLT
		.LVL346:
		.LBE156:
		.LBE155:
				jmp	.L515
		.LVL487:
		.L524:
				endbr64
  533 ASS(-3):
  534     OP = AND;  LITVAL = VAL1&VAL
		.LVL488:
				movl	4(%rsp), %eax
				andl	64(%rbx), %eax
				movl	%eax, 12(%rsp)
		.LVL489:
				movl	$1031, 8(%rsp)
		
		.LVL490:
		.L498:
  535     ->BOP
  536 ASS(-4):
  537     OP = OR;  LITVAL = VAL1!VAL
		.LVL495:
				movl	4(%rsp), %eax
				orl	64(%rbx), %eax
				movl	%eax, 12(%rsp)
		.LVL496:
				movl	$1543, 8(%rsp)
		
  538     ->BOP
				jmp	.L498
		.LVL497:
		.L526:
				endbr64
  539 ASS(-5):
				testl	%edi, %edi
				js	.L359
				subq	$8, %rsp
				movl	%edi, _imp_InStream(%rip)
				movslq	%edi, %rdi
		.LVL267:
				leaq	(%rdi,%rdi,8), %rax
				salq	$5, %rax
				leaq	_imp_infile(%rip), %rdx
				movq	8(%rdx,%rax), %rax
				movq	%rax, _imp_INFILE(%rip)
				leaq	__PRETTY_FUNCTION__.53(%rip), %rdi
				call	check_instream@PLT
		.LVL268:
				addq	$8, %rsp
				ret
		.LVL269:
		.L359:
				ret
		.LFE136:
		OUTPUTWORD.44:
		.LVL270:
		.LFB248:
  540     OP = XOR;  LITVAL = VAL1!!VAL
		.LBB116:
				movl	$1, _imp_OutStream(%rip)
		
				movq	296+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				leaq	__PRETTY_FUNCTION__.85(%rip), %rdi
				call	check_outstream@PLT
		.LVL308:
		.LBE116:
		.LBE115:
				movl	$10, %ebx
		.LVL309:
		.L382:
		.LDL100:
		.LBE117:
		.LBE118:
		.LBB124:
				movl	$2, _imp_OutStream(%rip)
		
				movq	584+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				leaq	__PRETTY_FUNCTION__.85(%rip), %rdi
				call	check_outstream@PLT
		.LVL320:
		.LBE124:
		.LBE123:
		.LBB158:
				movl	$0, _imp_OutStream(%rip)
		
				movq	8+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				leaq	__PRETTY_FUNCTION__.85(%rip), %rdi
				call	check_outstream@PLT
		.LVL348:
		.LBE158:
		.LBE157:
		.LBB162:
				movl	$2, _imp_OutStream(%rip)
		
				movq	584+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				leaq	__PRETTY_FUNCTION__.85(%rip), %rdi
				call	check_outstream@PLT
		.LVL351:
		.L402:
		.LBE162:
		.LBE161:
		.LVL498:
				movl	4(%rsp), %eax
				xorl	64(%rbx), %eax
				movl	%eax, 12(%rsp)
		.LVL499:
				movl	$1799, 8(%rsp)
		
		.LBB190:
				movl	$2, _imp_OutStream(%rip)
		
				movq	584+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				leaq	__PRETTY_FUNCTION__.85(%rip), %rbx
				movq	%rbx, %rdi
				call	check_outstream@PLT
		.LVL631:
		.LBE190:
		.LBE189:
		.LBB200:
				movl	$0, _imp_OutStream(%rip)
		
				movq	8+_imp_outfile(%rip), %rax
				movq	%rax, _imp_OUTFILE(%rip)
				addq	$256, %rsp
				movq	%rbx, %rdi
				call	check_outstream@PLT
		.LVL640:
		.LBE200:
		.LBE199:
  541     ->BOP
				jmp	.L498
		.LVL500:
		.L527:
				endbr64
		.LBB192:
				subq	$256, %rsp
				movq	%r10, (%rsp)
				movq	%r11, 8(%rsp)
				movq	%r8, 16(%rsp)
				movq	%r9, 24(%rsp)
				movq	%rsi, 32(%rsp)
				movq	%rdi, 40(%rsp)
				movq	%rax, 48(%rsp)
				movq	%rdx, 56(%rsp)
				movq	%r12, 64(%rsp)
				movq	%r13, 72(%rsp)
				movdqa	448(%rsp), %xmm5
		
				movups	%xmm5, 80(%rsp)
				movups	%xmm0, 96(%rsp)
				movups	%xmm2, 112(%rsp)
				movups	%xmm4, 128(%rsp)
		
				movups	%xmm6, 144(%rsp)
		
				movups	%xmm8, 160(%rsp)
		
				movups	%xmm10, 176(%rsp)
		
				movups	%xmm12, 192(%rsp)
		
				movups	%xmm14, 208(%rsp)
		
				movdqa	592(%rsp), %xmm7
		
				movups	%xmm7, 224(%rsp)
		
				movq	$0, 240(%rsp)
		
		
				movq	$0, 248(%rsp)
		
		
				movl	$1, %edi
				call	_imp_openinput@PLT
		.LVL633:
		.LBE192:
		.LBE191:
		.LBB194:
				movq	%r10, (%rsp)
				movq	%r11, 8(%rsp)
				movq	%r8, 16(%rsp)
				movq	%r9, 24(%rsp)
				movq	%rsi, 32(%rsp)
				movq	%rdi, 40(%rsp)
				movq	%rax, 48(%rsp)
				movq	%rdx, 56(%rsp)
				movq	%r12, 64(%rsp)
				movq	%r13, 72(%rsp)
				movdqa	704(%rsp), %xmm5
		
				movups	%xmm5, 80(%rsp)
				movups	%xmm0, 96(%rsp)
				movups	%xmm2, 112(%rsp)
				movups	%xmm4, 128(%rsp)
		
				movups	%xmm6, 144(%rsp)
		
				movups	%xmm8, 160(%rsp)
		
				movups	%xmm10, 176(%rsp)
		
				movups	%xmm12, 192(%rsp)
		
				movups	%xmm14, 208(%rsp)
		
				movdqa	848(%rsp), %xmm7
		
				movups	%xmm7, 224(%rsp)
		
				movq	$0, 240(%rsp)
		
		
				movq	$0, 248(%rsp)
		
		
				movl	$2, %edi
				call	_imp_openinput@PLT
		.LVL635:
		.LBE194:
		.LBE193:
  542 ASS(-6):
		.LBB196:
				movq	%r10, (%rsp)
				movq	%r11, 8(%rsp)
				movq	%r8, 16(%rsp)
				movq	%r9, 24(%rsp)
				movq	%rsi, 32(%rsp)
				movq	%rdi, 40(%rsp)
				movq	%rax, 48(%rsp)
				movq	%rdx, 56(%rsp)
				movq	%r12, 64(%rsp)
				movq	%r13, 72(%rsp)
				movdqa	960(%rsp), %xmm5
		
				movups	%xmm5, 80(%rsp)
				movups	%xmm0, 96(%rsp)
				movups	%xmm2, 112(%rsp)
				movups	%xmm4, 128(%rsp)
		
				movups	%xmm6, 144(%rsp)
		
				movups	%xmm8, 160(%rsp)
		
				movups	%xmm10, 176(%rsp)
		
				movups	%xmm12, 192(%rsp)
		
				movups	%xmm14, 208(%rsp)
		
				movdqa	1104(%rsp), %xmm7
		
				movups	%xmm7, 224(%rsp)
		
				movq	$0, 240(%rsp)
		
		
				movq	$0, 248(%rsp)
		
		
				movl	$1, %edi
				call	_imp_openoutput@PLT
		.LVL637:
		.LBE196:
		.LBE195:
		.LBB198:
				movq	%r10, (%rsp)
				movq	%r11, 8(%rsp)
				movq	%r8, 16(%rsp)
				movq	%r9, 24(%rsp)
				movq	%rsi, 32(%rsp)
				movq	%rdi, 40(%rsp)
				movq	%rax, 48(%rsp)
				movq	%rdx, 56(%rsp)
				movq	%r12, 64(%rsp)
				movq	%r13, 72(%rsp)
				movdqa	1216(%rsp), %xmm5
		
				movups	%xmm5, 80(%rsp)
				movups	%xmm0, 96(%rsp)
				movups	%xmm2, 112(%rsp)
				movups	%xmm4, 128(%rsp)
		
				movups	%xmm6, 144(%rsp)
		
				movups	%xmm8, 160(%rsp)
		
				movups	%xmm10, 176(%rsp)
		
				movups	%xmm12, 192(%rsp)
		
				movups	%xmm14, 208(%rsp)
		
				movdqa	1360(%rsp), %xmm7
		
				movups	%xmm7, 224(%rsp)
		
				movq	$0, 240(%rsp)
		
		
				movq	$0, 248(%rsp)
		
		
				movl	$2, %edi
				call	_imp_openoutput@PLT
		.LVL639:
		.LBE198:
		.LBE197:
  543     OP = SLLS;  LITVAL = VAL1<<VAL
		.LVL501:
				movl	64(%rbx), %ecx
				movl	4(%rsp), %eax
				sall	%cl, %eax
				movl	%eax, 12(%rsp)
		.LVL502:
				movl	$29960, 8(%rsp)
		
		.LVL596:
		.L528:
  544     OP = SLHL %IF TYPE # 0
				cmpl	$0, 68(%rbx)
				je	.L621
				movl	$3332, 8(%rsp)
		
				jmp	.L521
		.LVL504:
		.L529:
				endbr64
  545     ->NOP
  546 ASS(-7):
  547     OP = SRLS;  LITVAL = VAL1>>VAL
		.LVL505:
				movl	64(%rbx), %ecx
				movl	4(%rsp), %eax
				shrl	%cl, %eax
				movl	%eax, 12(%rsp)
		.LVL506:
				movl	$29704, 8(%rsp)
		
				jmp	.L528
		.LVL598:
		.L644:
  548     OP = SRHL %IF TYPE # 0
				cmpl	$0, 68(%rbx)
				je	.L622
				movl	$3076, 8(%rsp)
		
				jmp	.L521
		.LVL508:
		.L530:
				endbr64
  549     ->NOP
  550 
		.LBB202:
				call	_imp_closeinput@PLT
		.LVL866:
		.LBE202:
		.LBE201:
				movl	$1, %edi
				call	_imp_SELECTINPUT
		.LVL867:
  551 ASS(-8):                              !TYPE_VAL
  552     TYPE = VAL1
  553     TYPE = 0 %IF TYPE&OPMASK = MACRO; !SAFETY
				movl	4(%rsp), %esi
				movl	%esi, %eax
				andl	$61440, %eax
				cmpl	$40960, %eax
				je	.L531
		.LDL124:
  554     TYPE = 0 %IF TYPE&(OPMASK+FMASK) = FMASK
				movl	%esi, %eax
				andl	$63488, %eax
				cmpl	$2048, %eax
				jne	.L641
				movl	$0, 68(%rbx)
				jmp	.L515
		.L641:
				movl	%esi, 68(%rbx)
				jmp	.L515
		.L533:
				endbr64
				jmp	.L515
		.LVL590:
		.L619:
  555     ->POP
  556 
  557 ASS(-11):                             !COMPARE
  558     K = INTEGER(Q);  Q = Q+1
				movl	%r14d, %edi
				call	INTEGER.39
		.LVL509:
				movl	%eax, %ebp
		.LVL510:
				addl	$2, %r12d
		.LVL511:
  559     %IF MODE <= 0 %START
				cmpl	$0, 20(%rbx)
				jle	.L534
		.LDL125:
  560        VAL1 = TYPE1 %AND VAL = TYPE %IF TYPE1 # TYPE
				movl	68(%rbx), %eax
		.LVL516:
				cmpl	%r15d, %eax
				je	.L537
				movl	%eax, 64(%rbx)
				movl	%r15d, 4(%rsp)
		.L537:
  561        LITVAL = \3
		.LVL517:
  562        LITVAL = 1 %IF VAL1 < VAL
				movl	64(%rbx), %edx
				movl	$1, %eax
				cmpl	%edx, 4(%rsp)
				jge	.L643
		.L538:
		.LVL518:
  563        LITVAL = 2 %IF VAL1 > VAL
				cmpl	%edx, 4(%rsp)
				je	.L624
				movl	$2, %eax
				jmp	.L538
		.L624:
				movl	$-4, %eax
				jmp	.L538
		.LVL521:
		.L642:
  564        K = K&LITVAL;  K = \0 %IF K # 0
				testl	%ebp, %eax
				setne	%al
		.LVL519:
				movzbl	%al, %eax
				negl	%eax
				movl	%eax, %ebp
				jmp	.L551
		.LVL520:
		.L643:
		.L539:
  565     %finish %ELSE %UNLESS CREG=16 %AND TYPE1=CTYPE %AND VAL1=CVAL %AND TYPE=VAL=0 %START
				cmpl	$16, 56(%rbx)
				jne	.L535
				cmpl	%r15d, 36(%rbx)
				jne	.L535
				movl	4(%rsp), %eax
		.LVL512:
				cmpl	32(%rbx), %eax
				jne	.L535
				movl	64(%rbx), %eax
				cmpl	%eax, 68(%rbx)
				jne	.L551
				testl	%eax, %eax
				je	.L551
		.L535:
  566        %IF TYPE1 # REG %START
				cmpl	$128, %r15d
				je	.L544
  567           SWOP
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	SWOP.23
		.LVL513:
				movl	28(%rsp), %r15d
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
  568           %IF TYPE1 # REG %START
				cmpl	$128, %r15d
				jne	.L642
		.LDL126:
  569              LOAD TEMP;  SWOP
		.LBB94:
				call	_imp_space@PLT
		.LVL281:
		.LBE94:
		.LBE93:
				leaq	16(%rsp), %r14
				movq	%r14, %r10
				call	LOADTEMP.22
		.LVL522:
				movq	%r14, %r10
				call	SWOP.23
		.LVL523:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
  570           %finish %ELSE %START
		.LBB98:
		.LBE98:
		.LBE97:
				call	_imp_spaces@PLT
		.LVL291:
		.LBE99:
		.LBE100:
		.L541:
		.L543:
		.LVL524:
		.L544:
  571              K = K!!3 %UNLESS K = 3 %OR K = \3
				cmpl	$-4, %ebp
				je	.L544
				cmpl	$3, %ebp
				sete	%dl
				movl	%ebp, %eax
				xorl	$3, %eax
				testb	%dl, %dl
				cmove	%eax, %ebp
		.LVL514:
				jmp	.L544
		.LVL515:
		.L534:
  572           %FINISH
		.LBB72:
				call	_imp_newline@PLT
		.LVL96:
		.LBE72:
		.LBE71:
		.LBB78:
				call	_imp_newline@PLT
		.LVL103:
		.LBE78:
		.LBE77:
		.LBB160:
				call	_imp_newline@PLT
		.LVL350:
		.LBE160:
		.LBE159:
  573        %FINISH
		.LBB74:
				movl	$2, %edi
				call	_imp_newlines@PLT
		.LVL98:
		.LBE74:
		.LBE73:
  574        %UNLESS CREG = VAL1 %AND CTYPE = TYPE %AND CVAL = VAL %START
				movl	4(%rsp), %eax
				cmpl	56(%rbx), %eax
				jne	.L545
				movl	68(%rbx), %eax
				cmpl	%eax, 36(%rbx)
				jne	.L545
				movl	64(%rbx), %eax
				cmpl	%eax, 32(%rbx)
				je	.L551
		.L545:
  575           CREG = VAL1;  CTYPE = TYPE;  CVAL = VAL
				movl	4(%rsp), %eax
				movl	%eax, 56(%rbx)
				movl	68(%rbx), %edx
				movl	%edx, 36(%rbx)
				movl	64(%rbx), %eax
				movl	%eax, 32(%rbx)
  576           %UNLESS TYPE = VAL = 0 %START
				cmpl	%eax, %edx
				jne	.L628
				testl	%eax, %eax
				jne	.L546
		.L628:
		.LDL127:
  577              OP = COMP
		.LVL528:
				movl	$2311, %eax
				jmp	.L548
		.L549:
				movl	$2311, %eax
				jmp	.L548
		.LVL532:
		.L626:
  578              %IF TYPE = ATYPE %AND VAL = AVAL %START
				cmpl	60(%rbx), %edx
				jne	.L549
				cmpl	44(%rbx), %eax
				jne	.L549
  579                 TYPE = REG;  VAL = ACC
				movl	$128, 68(%rbx)
				movl	40(%rbx), %eax
				movl	%eax, 64(%rbx)
  580              %FINISH
  581              %IF TYPE&BMASK # 0 %START
				testb	$1, %dh
				je	.L625
  582                 OP = CLB
		.LVL529:
				movl	$37890, %eax
				jmp	.L548
		.LVL531:
		.L625:
				movl	$37890, %eax
				jmp	.L548
		.LVL533:
		.L552:
				endbr64
  583                 FAULT('I') %UNLESS K = 3 %OR K = \3
				cmpl	$3, %ebp
				je	.L626
				cmpl	$-4, %ebp
				je	.L626
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL530:
  584              %FINISH
  585           %finish %ELSE %START
  586              OP = LOAD
		.LVL525:
				movl	$2063, %eax
		.LVL526:
		.L548:
  587              TYPE = REG;  VAL = VAL1
				movl	$128, 68(%rbx)
				movl	4(%rsp), %eax
				movl	%eax, 64(%rbx)
  588           %FINISH
  589           PLANT INST(VAL1<<4+OP)
				movl	4(%rsp), %edx
				movl	%edx, 24(%rsp)
				movl	%r15d, 28(%rsp)
				movl	%edx, %edi
				sall	$4, %edi
				addl	%eax, %edi
				leaq	16(%rsp), %r10
				call	PLANTINST.25
		.LVL527:
		.L540:
		.L550:
		.L551:
  590        %FINISH
  591     %FINISH
  592     COND = K
				movl	%ebp, 48(%rbx)
  593     ->GET
				jmp	.L494
		.L546:
  594 
  595 ASS(-12):                             !TEST CC
  596     COND = \VAL
				movl	64(%rbx), %eax
				notl	%eax
				movl	%eax, 48(%rbx)
  597     ->GET
				jmp	.L494
		.L553:
				endbr64
  598 
  599 ASS(-13):                             !AND,WHILE
  600     %IF MODE > 0 %START
				cmpl	$0, 20(%rbx)
				jg	.L554
		.LDL128:
  601        SET JUMP(16_1000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$4096, %edi
				call	SETJUMP.26
		.LVL534:
  602     %finish %ELSE %START
				jmp	.L555
		.L557:
				endbr64
  603        %RETURN %IF COND # 0;          !CONDITION FALSE
				cmpl	$0, 48(%rbx)
				jne	.L489
		.L555:
		.LDL129:
  604     %FINISH
  605     %RETURN %IF Q = QLIM
				cmpl	%r14d, QLIM.123(%rip)
				jne	.L490
				jmp	.L489
		.L554:
  606     ->NEW
  607 
  608 ASS(-14):                             !OR
  609     %IF MODE > 0 %START
				cmpl	$0, 20(%rbx)
				jg	.L558
		.LDL130:
  610        COND = \COND
				notl	48(%rbx)
  611        SET JUMP(16_3000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$12288, %edi
				call	SETJUMP.26
		.LVL535:
  612     %finish %ELSE %START
				jmp	.L490
		.L559:
				endbr64
  613        %RETURN %IF COND = 0;          !CONDITION TRUE
				cmpl	$0, 48(%rbx)
				jne	.L490
				jmp	.L489
		.L558:
  614     %FINISH
  615     ->NEW
  616 
  617 ASS(-15):                             !IF
  618     SET JUMP(16_2000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$8192, %edi
				call	SETJUMP.26
		.LVL536:
  619     %RETURN
		.L489:
  620 
  621 ASS(-16):                             !ELSE
  622     COND = \0
				movl	$-1, 48(%rbx)
  623     SET JUMP(16_4000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$16384, %edi
				call	SETJUMP.26
		.LVL539:
  624     %RETURN
				jmp	.L489
		.L561:
				endbr64
  625 
  626 ASS(-17):                             !IF AFTER ELSE
  627     SET JUMP(16_6000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$24576, %edi
				call	SETJUMP.26
		.LVL540:
  628     %RETURN
				jmp	.L489
		.L562:
				endbr64
  629 
  630 ASS(-18):                             !MACCALL IF
  631     SET JUMP(16_8000)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$32768, %edi
				call	SETJUMP.26
		.LVL541:
  632     %RETURN
				jmp	.L489
		.L563:
				endbr64
  633 
  634 ASS(-20):                             !HASH
  635     TYPE = TYPE&(UMASK+63)
				andl	$575, 68(%rbx)
  636     ->GET
				jmp	.L494
		.L564:
				endbr64
  637 
  638 ASS(-21):                             !INDEX
  639     FAULT('I') %IF TYPE1&REGXMASK # 0
				testb	$-112, %r15b
				jne	.L645
		.L565:
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL545:
				jmp	.L565
		.L646:
  640     %IF TYPE&MEMMASK # 0 %START
				testb	$64, 68(%rbx)
				je	.L569
  641        %IF MODE > 0 %START
				cmpl	$0, 20(%rbx)
				jle	.L646
		.LDL131:
  642           ZQUERY = 1
				movl	$1, ZQUERY.66(%rip)
		
  643           LOAD TEMP
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	LOADTEMP.22
		.LVL542:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
  644           ZQUERY = 0
				movl	$0, ZQUERY.66(%rip)
		
  645        %finish %ELSE FAULT('A')
		.L566:
		.L569:
				movq	%rbx, %r10
				movl	$65, %edi
				call	FAULT.45
		.LVL546:
  646     %FINISH
  647     %IF TYPE = REG %START
				cmpl	$128, 68(%rbx)
				jne	.L568
				jmp	.L568
		.LVL547:
		.L647:
  648        TYPE = XMASK+VAL;  VAL = 0
				movl	64(%rbx), %eax
				addl	$16, %eax
				movl	%eax, 68(%rbx)
				movl	$0, 64(%rbx)
		.L568:
  649     %FINISH
  650     ZQUERY = 0
				movl	$0, ZQUERY.66(%rip)
		
  651     FAULT('I') %IF TYPE1&TYPE&RELMASK # 0
				movl	68(%rbx), %ebp
		.LVL543:
				movl	%ebp, %eax
				andl	%r15d, %eax
				testb	$32, %al
				jne	.L647
		.L570:
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL548:
				jmp	.L570
		.LVL549:
		.L571:
				endbr64
  652     TYPE = TYPE1!TYPE!MEMMASK;  VAL = VAL1+VAL
				orl	%r15d, %ebp
				orl	$64, %ebp
				movl	%ebp, 68(%rbx)
				movl	4(%rsp), %eax
				addl	%eax, 64(%rbx)
  653     ->POP
				jmp	.L515
		.LVL544:
		.L645:
  654 
  655 ASS(-22):                             !MINST SEPARATOR
  656     %IF TYPE1&OPMASK = 16_7000 %START
				movl	%r15d, %eax
				andl	$61440, %eax
				cmpl	$28672, %eax
				je	.L572
		.LDL132:
  657        %IF TYPE1&16_10 = 0 %START;    !REG-TYPE INST
				testb	$16, %r15b
				je	.L575
		.LDL133:
  658           FAULT('I') %IF TYPE # REG
				cmpl	$128, 68(%rbx)
				je	.L580
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL552:
				jmp	.L580
		.L648:
  659        %finish %ELSE %START
  660           VAL = \VAL %AND VAL1 = VAL1!!16_0100 %IF VAL < 0
				movl	64(%rbx), %eax
				testl	%eax, %eax
				jns	.L576
				notl	%eax
				movl	%eax, 64(%rbx)
				xorl	$256, 4(%rsp)
		
		.L576:
  661           FAULT('I') %IF TYPE # 0 %OR VAL > 15
				cmpl	$0, 68(%rbx)
				jne	.L579
				cmpl	$15, 64(%rbx)
				jle	.L580
		.L579:
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL551:
		.L578:
		.L580:
  662        %FINISH
  663        TYPE = TYPE1+16_8000;  VAL = VAL1&16_FF0F+VAL<<4
				addl	$32768, %r15d
				movl	%r15d, 68(%rbx)
				movl	64(%rbx), %eax
				sall	$4, %eax
				movl	4(%rsp), %edx
				andl	$65295, %edx
				addl	%edx, %eax
				movl	%eax, 64(%rbx)
  664     %finish %ELSE %IF TYPE1&OPMASK = 16_F000 %START
				cmpl	$61440, %eax
				jne	.L648
				jmp	.L515
		.L575:
		.LDL134:
  665        PROGREF %IF VAL1&16_FC0F = 16_0003; !BAL,BTC,BFC
				movl	4(%rsp), %eax
				andl	$64527, %eax
				cmpl	$3, %eax
				je	.L649
		.L581:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	PROGREF.27
		.LVL554:
				jmp	.L581
		.L582:
				endbr64
  666        FORM INST(VAL1)
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	%eax, %edi
				call	FORMINST.21
		.LVL550:
  667     %finish %ELSE FAULT('I')
				jmp	.L515
		.L572:
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL553:
				jmp	.L515
		.L649:
  668     ->POP
  669 
  670 ASS(-23):                             !MACHINE INST
  671     SET JUMP(16_1000) %IF COND # 0
				cmpl	$0, 48(%rbx)
				jne	.L650
		.L583:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$4096, %edi
				call	SETJUMP.26
		.LVL556:
				jmp	.L583
		.L584:
				endbr64
  672     PLANT VAL
				movq	%rbx, %r10
				call	PLANTVAL.1
		.LVL555:
  673     CREG = -1;  ATYPE = -1
				movl	$-1, 56(%rbx)
				movl	$-1, 60(%rbx)
  674     %RETURN
				jmp	.L489
		.L650:
  675 
  676 ASS(-24):                             !LOAD
  677     LOAD TEMP %IF TYPE # REG
				cmpl	$128, 68(%rbx)
				je	.L585
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				call	LOADTEMP.22
		.LVL557:
				movl	24(%rsp), %eax
				movl	%eax, 4(%rsp)
				movl	28(%rsp), %r15d
		.L585:
  678     Q = QBASE
				movl	QBASE.125(%rip), %r12d
		.LVL558:
  679     ->GET
				jmp	.L494
		.LVL559:
		.L586:
				endbr64
  680 
  681 ASS(-25):                             !STORE (TYPE1,VAL1 -> TYPE,VAL)
  682     %IF TYPE = REG %START
				movl	68(%rbx), %eax
				cmpl	$128, %eax
				je	.L587
		.LDL135:
  683        SWOP %AND LOAD REG(VAL1) %IF VAL1 # VAL
				movl	4(%rsp), %eax
				cmpl	%eax, 64(%rbx)
				je	.L489
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %rbx
				movq	%rbx, %r10
				call	SWOP.23
		.LVL564:
				movq	%rbx, %r10
				movl	24(%rsp), %edi
				call	LOADREG.24
		.LVL565:
				jmp	.L489
		.L590:
  684     %finish %ELSE %START
  685        ATYPE = -1 %IF ATYPE&MEMMASK # 0
				testb	$64, 60(%rbx)
				je	.L588
				movl	$-1, 60(%rbx)
		.L588:
  686        %IF FLAG = 0 %START
				cmpl	$0, 52(%rbx)
				je	.L590
		.LDL136:
  687           %IF VAL1 = ACC %AND ATYPE < 0 %START
				movl	4(%rsp), %esi
				cmpl	%esi, 40(%rbx)
				jne	.L594
				cmpl	$0, 60(%rbx)
				jns	.L594
  688              K = TYPE&15
		.LVL566:
  689              ATYPE = TYPE %AND AVAL = VAL %IF K = 0 %OR 1<<K&TEMPS = 0
				movl	%eax, %edx
				andl	$15, %edx
		.LVL567:
				je	.L593
				movl	TEMPS.97(%rip), %esi
				btl	%edx, %esi
				jc	.L594
		.L593:
				movl	%eax, 60(%rbx)
				movl	64(%rbx), %edx
		.LVL568:
				movl	%edx, 44(%rbx)
		.L592:
		.LVL569:
		.L594:
  690           %FINISH
  691           OP = STORE;  OP = STB %IF TYPE&BMASK # 0
				andl	$256, %eax
				cmpl	$1, %eax
				sbbl	%eax, %eax
				andl	$-37376, %eax
				addl	$37378, %eax
				jmp	.L591
		.LVL570:
		.L595:
				endbr64
  692        %finish %ELSE %START
  693           CREG = 16;  CTYPE = TYPE;  CVAL = VAL
				movl	$16, 56(%rbx)
				movl	%eax, 36(%rbx)
				movl	64(%rbx), %eax
				movl	%eax, 32(%rbx)
  694           OP = AHM
		.LVL560:
				movl	$8450, %eax
		.LVL561:
		.L591:
  695        %FINISH
  696        PLANT INST(VAL1<<4+OP)
				movl	4(%rsp), %esi
				movl	%esi, 24(%rsp)
				movl	%r15d, 28(%rsp)
				movl	%esi, %edi
				sall	$4, %edi
				addl	%eax, %edi
				leaq	16(%rsp), %r10
				call	PLANTINST.25
		.LVL562:
				jmp	.L489
		.LVL563:
		.L587:
  697     %FINISH
  698     %RETURN
  699 
  700 ASS(-26):                             !JUMP
  701     SET JUMP(16_1000) %IF INTEGER(NP)&16_F000 = 16_3000; !OR
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL571:
				andl	$61440, %eax
				cmpl	$12288, %eax
				je	.L651
		.L596:
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %r10
				movl	$4096, %edi
				call	SETJUMP.26
		.LVL580:
				jmp	.L596
		.LVL581:
		.L652:
  702     %IF FLAG < 0 %START;              !REPEAT
				cmpl	$0, 52(%rbx)
				jns	.L602
  703        FLAG = 0
				movl	$0, 52(%rbx)
  704        %IF PASS = 0 %START
				cmpl	$0, PASS.93(%rip)
				jne	.L602
  705           K = NP;  LITVAL = LOC
		.LVL572:
				movl	76(%rbx), %r12d
		.LVL573:
				movl	%r12d, %ebp
				addl	NP.138(%rip), %r12d
		.LVL574:
		.L598:
				movl	%r12d, %edi
				subl	%ebp, %edi
		.LVL575:
  706           %WHILE INTEGER(K)&16_1000 # 0 %CYCLE
				call	INTEGER.39
		.LVL576:
				testb	$16, %ah
				je	.L652
		.LDL137:
  707              K = K+2;  LITVAL = LITVAL-2
		.LVL577:
				subl	$2, %ebp
		.LVL578:
  708           %REPEAT
				jmp	.L598
		.LVL579:
		.L651:
  709           FLAG = 1 %IF LITVAL-VAL < 32
				subl	64(%rbx), %ebp
		.LVL582:
				cmpl	$31, %ebp
				jg	.L602
				movl	$1, 52(%rbx)
		.L597:
		.L601:
		.LVL583:
		.L602:
  710        %FINISH
  711     %FINISH
  712     PROGREF
				movl	4(%rsp), %eax
				movl	%eax, 24(%rsp)
				movl	%r15d, 28(%rsp)
				leaq	16(%rsp), %rbx
				movq	%rbx, %r10
				call	PROGREF.27
		.LVL584:
  713     PLANT JUMP
				movq	%rbx, %r10
				call	PLANTJUMP.28
		.LVL585:
  714     %RETURN
				jmp	.L489
		.LVL586:
		.L603:
				endbr64
		.L609:
				endbr64
  715 
  716 %END;  !ASSEMBLE
  717 
  718 %ROUTINE LOOKUP(%INTEGER CONTROL)
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movl	%edi, %r12d
				movq	%r10, %rbp
  719 !ALL DICT OPERATIONS LOCALISED HERE
  720 !CONTROL = 0 (LOOKUP ONLY), 1 (FORWARD OK),
  721 !          2 (REDEF), 3 (DEF),
  722 !          4 (MACPARM), 7 (LABEL)
  723 %INTEGER DP
  724     DP = DEFMIN;  DP = MP+5 %IF CONTROL = 4
		.LVL125:
				movl	DEFMIN.134(%rip), %ebx
				cmpl	$4, %edi
				jne	.L158
				movl	MP.131(%rip), %eax
				leal	5(%rax), %ebx
				jmp	.L158
		.LVL126:
		.L172:
  725     
				movl	_imp_current_line(%rip), %r9d
				testl	%r9d, %r9d
				movl	$725, %eax
				cmove	%eax, %r9d
				movq	_imp_current_file(%rip), %rax
				testq	%rax, %rax
		.LVL587:
		.LBB173:
		.LBI173:
  726 {}    %WHILE INTEGER(DP) # 0 %CYCLE
		.LDL33:
				movl	%ebx, %edi
				call	INTEGER.39
		.LVL131:
				testl	%eax, %eax
				je	.L172
				movl	$1, %edi
				call	exit@PLT
		.LVL589:
		.L604:
				endbr64
				jmp	.L609
		.L605:
				endbr64
				jmp	.L609
		.L606:
				endbr64
				jmp	.L609
		.L607:
				endbr64
				jmp	.L609
		.L608:
				endbr64
				jmp	.L609
		.L531:
				movl	$0, 68(%rbx)
  727 {}       ->YES %IF INTEGER(DP) = TAG1 %AND INTEGER(DP+1) = TAG2
				movl	%ebx, %edi
				call	INTEGER.39
		.LVL132:
				cmpl	16(%rbp), %eax
				jne	.L155
				leal	1(%rbx), %edi
				call	INTEGER.39
		.LVL133:
				cmpl	12(%rbp), %eax
				jne	.L155
		.LDL34:
  728 {}       DP = DP+4
				addl	$4, %ebx
		.LVL130:
				movq	56(%rsp), %rax
				subq	%fs:40, %rax
		
				jne	.L644
				addq	$72, %rsp
				popq	%rbx
				popq	%rbp
				popq	%r12
				popq	%r13
		.LVL537:
				popq	%r14
				popq	%r15
				ret
		.LVL538:
		.L560:
				endbr64
				call	__stack_chk_fail@PLT
		.LVL599:
		.LFE252:
		CONDIT.11:
		.LVL600:
		.LFB274:
  729 {}    %REPEAT
		.L158:
  730 
  731 !!%OWNINTEGER P
  732 !!    DP = DP-4
  733 !!REP:DP = DP+4
  734 !!    %LAC* DP; %OPR 640;!SNA; %JMP NO
  735 !!    %SAD TAG1; %OPR 512; %JMP REP
  736 !!    %LAC DP; %TAD #1; %DAC P
  737 !!    %LAC* P; %SAD TAG2; %JMP YES
  738 !!    ->REP
  739 !!NO:
  740     %RETURN %IF CONTROL&1 = 0;        !NO CREATION
				testb	$1, %r12b
				jne	.L153
		.LVL127:
		.L149:
  741 NEW:DEFMIN = DEFMIN-4;  DP = DEFMIN
				movl	DEFMIN.134(%rip), %r12d
		.LVL140:
				leal	-4(%r12), %ebx
		.LVL141:
				movl	%ebx, DEFMIN.134(%rip)
		.LVL142:
  742 !!    %MONITOR 21 %IF DP-QLIM <= 0
  743     !{}%signal 2,1 %IF DP-QLIM <= 0
  744 !!    INTEGER(DP) = TAG1;  INTEGER(DP+1) = TAG2
  745     set INTEGER(DP, TAG1);  set INTEGER(DP+1,  TAG2)
				movl	16(%rbp), %esi
				movl	%ebx, %edi
				call	SETINTEGER.8
		.LVL143:
				movl	12(%rbp), %esi
				leal	-3(%r12), %edi
				call	SETINTEGER.8
		.LVL144:
		.L159:
  746 !!SET:INTEGER(DP+2) = TYPE;  INTEGER(DP+3) = VAL
  747 SET:set INTEGER(DP+2, TYPE);  set INTEGER(DP+3, VAL)
				movl	68(%rbp), %esi
				leal	2(%rbx), %edi
				call	SETINTEGER.8
		.LVL145:
				movl	64(%rbp), %esi
				leal	3(%rbx), %edi
				call	SETINTEGER.8
		.LVL146:
  748     %RETURN
				jmp	.L149
		.LVL147:
		.L175:
  749 YES:%IF CONTROL&2 = 0 %START;         !NOT DEF CLASS
				testb	$2, %r12b
				je	.L173
		.LDL35:
  750        TYPE = INTEGER(DP+2);  VAL = INTEGER(DP+3)
				leal	2(%rbx), %edi
				call	INTEGER.39
		.LVL137:
				movl	%eax, 68(%rbp)
				leal	3(%rbx), %edi
				call	INTEGER.39
		.LVL138:
				movl	%eax, 64(%rbp)
  751        %RETURN
				jmp	.L149
		.L174:
  752     %FINISH
  753     %IF CONTROL = 3 %START
				cmpl	$3, %r12d
				je	.L174
		.L160:
  754        ->NEW %IF DP-INTEGER(BP) >= 0; !GLOBAL
				movl	BP.136(%rip), %edi
				call	INTEGER.39
		.LVL139:
				cmpl	%eax, %ebx
				jl	.L175
		.L153:
		.LDL39:
		.LDL40:
  755        FAULT('D')
				movq	%rbp, %r10
				movl	$68, %edi
				call	FAULT.45
		.LVL148:
  756     %FINISH
  757     ->SET %IF CONTROL # 7
				cmpl	$7, %r12d
				jne	.L159
		.LDL36:
				jmp	.L159
		.L162:
  758     %IF INTEGER(DP+2)&OPFMASK = FMASK %START
				leal	2(%rbx), %edi
				call	INTEGER.39
		.LVL134:
				andl	$63488, %eax
				cmpl	$2048, %eax
				je	.L162
		.LDL37:
  759        VAL = INTEGER(DP+3)
				leal	3(%rbx), %edi
				call	INTEGER.39
		.LVL149:
				movl	%eax, %edi
				movl	%eax, 64(%rbp)
  760        %IF PASS = 0 %START
				cmpl	$0, PASS.93(%rip)
				je	.L164
		.LDL41:
  761 !!          INTEGER(VAL) = LOC
  762           set INTEGER(VAL, LOC)
				movl	76(%rbp), %esi
				call	SETINTEGER.8
		.LVL153:
  763        %finish %ELSE %START
		.L165:
		.L167:
  764           FAULT('P') %AND LOC=INTEGER(VAL) %IF INTEGER(VAL) # LOC
				call	INTEGER.39
		.LVL150:
				cmpl	76(%rbp), %eax
				je	.L167
				movq	%rbp, %r10
				movl	$80, %edi
				call	FAULT.45
		.LVL151:
				movl	64(%rbp), %edi
				call	INTEGER.39
		.LVL152:
				movl	%eax, 76(%rbp)
				jmp	.L167
		.L164:
  765        %FINISH
  766        VAL = LOC
				movl	76(%rbp), %eax
				movl	%eax, 64(%rbp)
  767     %finish %ELSE %START
				jmp	.L159
		.LFE263:
		TAG.34:
		.LFB268:
  768        ->NEW %IF DP-INTEGER(BP) >= 0
				movl	BP.136(%rip), %edi
				call	INTEGER.39
		.LVL135:
				cmpl	%eax, %ebx
				jge	.L153
		.LDL38:
  769        FAULT('D')
				movq	%rbp, %r10
				movl	$68, %edi
				call	FAULT.45
		.LVL136:
				jmp	.L159
		.L173:
  770     %FINISH
  771     ->SET
  772 %END
  773 
  774 %ROUTINE TAGREF
				popq	%rbx
		.LVL128:
				popq	%rbp
				popq	%r12
				ret
		.LVL129:
		.L155:
				pushq	%rbx
				movq	%r10, %rbx
  775 %OWNINTEGER B=2184, W=24717
  776     %IF TERM = '(' %START
				cmpl	$40, 8(%r10)
				jne	.L203
  777        TYPE = 0;  VAL = 0
				movl	$0, 68(%r10)
		
				movl	$0, 64(%r10)
		
  778        %RETURN %IF TAG1 = W
				movl	16(%r10), %eax
				cmpl	$24717, %eax
				je	.L202
		.LDL47:
  779        TYPE = BMASK
				movl	$256, 68(%r10)
		
  780        %RETURN %IF TAG1 = B
				cmpl	$2184, %eax
				je	.L202
		.L203:
		.LDL48:
  781     %FINISH
  782     TYPE = LOCTYPE+FMASK+UMASK;  VAL = LABMIN-1
				movl	72(%rbx), %eax
				addl	$2560, %eax
				movl	%eax, 68(%rbx)
				movl	LABMIN.129(%rip), %eax
				subl	$1, %eax
				movl	%eax, 64(%rbx)
  783     LOOKUP(1)
				movq	%rbx, %r10
				movl	$1, %edi
				call	LOOKUP.32
		.LVL163:
  784     %IF TYPE&OPFMASK = FMASK %START
				movl	68(%rbx), %eax
				andl	$63488, %eax
				cmpl	$2048, %eax
				jne	.L202
  785        %IF VAL = LABMIN-1 %START
				movl	64(%rbx), %edi
				movl	LABMIN.129(%rip), %eax
				subl	$1, %eax
				cmpl	%edi, %eax
				jne	.L205
  786 !!          LABMIN = VAL;  %MONITOR 22 %IF LABMIN = ALMAX
  787           LABMIN = VAL;  !{}%signal 2,2 %IF LABMIN = ALMAX
				movl	%edi, LABMIN.129(%rip)
		.L205:
  788        %FINISH
  789        %IF PASS > 0 %START
				cmpl	$0, PASS.93(%rip)
				jle	.L207
  790           VAL = INTEGER(VAL)
				call	INTEGER.39
		.LVL164:
				movl	%eax, 64(%rbx)
  791           FAULT('U') %IF VAL = 0
				testl	%eax, %eax
				je	.L209
		.L206:
		.L207:
				movq	%rbx, %r10
				movl	$85, %edi
				call	FAULT.45
		.LVL165:
				jmp	.L207
		.LFE264:
		GETEXP.16:
		.LFB273:
  792        %FINISH
  793        TYPE = TYPE-FMASK
				subl	$2048, 68(%rbx)
  794     %FINISH
  795 %END
  796 
		.L204:
		.L202:
  797 %ROUTINE GET SYM
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %rbp
		.L55:
		.LDL8:
				popq	%rbx
				ret
		.L209:
  798     %CYCLE
  799        SYM = CHAR(GETPOS);  GETPOS = GETPOS+1
				movl	GETPOS.100(%rip), %ebx
				movl	%ebx, %edi
				call	CHAR.6
		.LVL50:
				movl	%eax, 4(%rbp)
				addl	$1, %ebx
				movl	%ebx, GETPOS.100(%rip)
  800        %RETURN %IF SYM # ' '
				cmpl	$32, %eax
				je	.L55
  801     %REPEAT
  802 %END
  803 
  804 %PREDICATE S(%INTEGER K)
				popq	%rbx
				popq	%rbp
				ret
		.LFE265:
		S.33:
		.LVL51:
		.LFB266:
  805     %FALSE %UNLESS K = SYM
				movl	$0, %eax
				cmpl	%edi, 4(%r10)
				je	.L61
		.L58:
		.LDL9:
  806     GET SYM
				call	GETSYM.7
		.LVL52:
  807     %TRUE
				movl	$1, %eax
				ret
		.LFE266:
		SS.17:
		.LVL53:
		.LFB267:
  808 %END
  809 
				ret
		.L61:
  810 %PREDICATE SS(%INTEGER K)
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movl	%edi, %ebp
				movq	%r10, %rbx
  811     %FALSE %UNLESS K = SYM = CHAR(GETPOS)
		.LBB70:
		.LVL54:
				movl	4(%r10), %r12d
		.LVL55:
				movl	GETPOS.100(%rip), %r13d
				movl	%r13d, %edi
		.LVL56:
				call	CHAR.6
		.LVL57:
		.LBE70:
				cmpl	%r12d, %ebp
				jne	.L66
				movl	$0, %edx
		.L63:
				cmpl	%eax, %r12d
				je	.L66
		.LVL58:
		.L62:
		.LDL10:
  812     GETPOS = GETPOS+1
				addl	$1, %r13d
				movl	%r13d, GETPOS.100(%rip)
  813     GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL62:
  814     %TRUE
				movl	$1, %edx
				jmp	.L62
		.LFE267:
		CODESYM.36:
		.LFB269:
  815 %END
  816 
				movl	%edx, %eax
				popq	%rbx
				popq	%rbp
		.LVL59:
				popq	%r12
		.LVL60:
				popq	%r13
				ret
		.LVL61:
		.L66:
  817 %PREDICATE TAG
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$40, %rsp
				movq	%fs:40, %rax
		
				movq	%rax, 24(%rsp)
				xorl	%eax, %eax
				leaq	80(%rsp), %rax
				movq	%rax, 16(%rsp)
				movq	%r10, (%rsp)
  818 %INTEGER J,K
  819     %ROUTINE CODE SYM
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %rbx
  820        SYM = CHAR(GETPOS);  GETPOS = GETPOS+1
				movl	GETPOS.100(%rip), %ebp
				movl	%ebp, %edi
				call	CHAR.6
		.LVL63:
				movq	(%rbx), %rdx
				movl	%eax, 4(%rdx)
				addl	$1, %ebp
				movl	%ebp, GETPOS.100(%rip)
  821        K = SYM-'0'
				movq	(%rbx), %rdx
				movl	4(%rdx), %eax
				subl	$48, %eax
				movl	%eax, 12(%rbx)
  822        %IF K >= 0 %START
				js	.L73
  823           TERM = -1 %AND %RETURN %IF K < 10
				cmpl	$9, %eax
				jg	.L76
				movl	$-1, 8(%rdx)
		.L68:
		.LDL11:
  824           K = SYM-'A'
				movl	4(%rdx), %eax
				subl	$65, %eax
				movl	%eax, 12(%rbx)
  825           %RETURN %IF K >= 0 %AND K < 26 %AND TERM = 0
				cmpl	$25, %eax
				jbe	.L77
		.L69:
		.L73:
				cmpl	$0, 8(%rdx)
				je	.L68
				jmp	.L73
		.LFE269:
		PACKTRIPLE.35:
		.LFB270:
  826        %FINISH
  827        TERM = SYM
				movl	4(%rdx), %eax
				movl	%eax, 8(%rdx)
  828     %END
				jmp	.L68
		.L77:
  829     %ROUTINE PACK TRIPLE
				pushq	%rbx
				movq	%r10, %rbx
				movq	(%r10), %rax
				cmpl	$0, 8(%rax)
				js	.L79
		.LDL12:
  830        ->T1 %IF TERM < 0
				popq	%rbx
				popq	%rbp
				ret
		.L76:
		.LDL15:
  831        J = ((K<<5+K)<<1+K)<<4+K+1111; !K*1073+1111
				movl	12(%r10), %eax
				movl	%eax, %edx
				sall	$5, %edx
				addl	%eax, %edx
				leal	(%rax,%rdx,2), %edx
				sall	$4, %edx
				leal	1111(%rax,%rdx), %eax
				movl	%eax, 8(%r10)
  832        CODE SYM
				call	CODESYM.36
		.LVL64:
  833        ->T2 %IF TERM # 0
				movq	(%rbx), %rax
				cmpl	$0, 8(%rax)
				jne	.L81
		.LDL13:
  834        J = (K<<3+K)<<2+K+111+J;       !J+K*37+111
				movl	12(%rbx), %eax
				leal	(%rax,%rax,8), %edx
				leal	111(%rax,%rdx,4), %eax
				addl	%eax, 8(%rbx)
  835        CODE SYM
				movq	%rbx, %r10
				call	CODESYM.36
		.LVL65:
  836        ->T3 %IF TERM # 0
				movq	(%rbx), %rax
				cmpl	$0, 8(%rax)
				je	.L85
		.L82:
		.LDL16:
  837        J = J+K+11
				movl	12(%rbx), %eax
				addl	8(%rbx), %eax
				addl	$11, %eax
				movl	%eax, 8(%rbx)
  838        CODE SYM
				movq	%rbx, %r10
				call	CODESYM.36
		.LVL68:
  839        %RETURN
				jmp	.L78
		.L86:
  840 T1:    J = ((K<<1+K)<<1+K)<<4-K+1;    !K*111+1
				movl	12(%r10), %edx
				leal	(%rdx,%rdx,2), %eax
				leal	(%rdx,%rax,2), %eax
				sall	$4, %eax
				subl	%edx, %eax
				addl	$1, %eax
				movl	%eax, 8(%r10)
  841        CODE SYM
				call	CODESYM.36
		.LVL67:
		.L81:
  842 T2:    %RETURN %IF TERM > 0
				movq	(%rbx), %rax
				cmpl	$0, 8(%rax)
				jle	.L86
		.L78:
		.LDL17:
  843        J = (K<<2+K)<<1+K+1+J;         !J+K*11+1
				movl	12(%rbx), %eax
				leal	(%rax,%rax,4), %edx
				leal	1(%rax,%rdx,2), %eax
				addl	%eax, 8(%rbx)
  844        CODE SYM
				movq	%rbx, %r10
				call	CODESYM.36
		.LVL69:
				jmp	.L82
		.LFE270:
		TAGIF.12:
		.LFB271:
  845 T3:    %RETURN %IF TERM > 0
				movq	(%rbx), %rax
				cmpl	$0, 8(%rax)
				jg	.L78
		.LDL14:
  846        J = J+K+1
				movl	12(%rbx), %eax
				addl	8(%rbx), %eax
				addl	$1, %eax
				movl	%eax, 8(%rbx)
  847        CODE SYM
				movq	%rbx, %r10
				call	CODESYM.36
		.LVL66:
  848     %END
				jmp	.L78
		.L79:
  849     K = SYM-'A'
				movl	4(%r10), %ecx
				leal	-65(%rcx), %eax
				movl	%eax, 12(%rsp)
  850     %FALSE %UNLESS K >= 0 %AND K < 26
				popq	%rbx
				ret
		.L85:
				movl	$0, %edx
				cmpl	$25, %eax
				jbe	.L198
		.L176:
		.LDL42:
  851     %FALSE %IF SYM = 'X' %AND CHAR(GETPOS)&128 # 0
				cmpl	$88, %ecx
				jne	.L178
				movl	GETPOS.100(%rip), %edi
				call	CHAR.6
		.LVL154:
				movl	$0, %edx
				testb	$-128, %al
				jne	.L176
		.L178:
  852     TERM = 0
				movl	$0, 8(%rbx)
  853     PACK TRIPLE
				movl	$0, 8(%rsp)
		
				movq	%rsp, %r10
				call	PACKTRIPLE.35
		.LVL155:
  854     TAG1 = J
				movl	8(%rsp), %eax
				movl	%eax, 16(%rbx)
  855     %CYCLE
  856        J = 0
				movl	$0, %r13d
				jmp	.L179
		.L200:
				movl	%r13d, %ebp
  857        PACK TRIPLE %IF TERM <= 0
				movl	%r13d, 8(%rsp)
				movq	%rsp, %r10
				call	PACKTRIPLE.35
		.LVL156:
				movl	8(%rsp), %ebp
				jmp	.L180
		.L201:
				cmpl	$0, 8(%rbx)
				jle	.L200
		.L180:
  858        TAG2 = J
				movl	%ebp, 12(%rbx)
  859        CODE SYM %WHILE TERM <= 0
				movl	8(%rbx), %eax
				movq	%rsp, %r12
				testl	%eax, %eax
				jg	.L184
		.L181:
				movl	%ebp, 8(%rsp)
				movq	%r12, %r10
				call	CODESYM.36
		.LVL159:
				movl	8(%rsp), %ebp
		.LDL44:
				movl	8(%rbx), %eax
				testl	%eax, %eax
				jle	.L181
		.L184:
		.LDL45:
  860        %EXIT %UNLESS TERM = QQ
		.LDL43:
				cmpl	%eax, QQ.106(%rip)
				jne	.L201
		.LDL46:
  861        TYPE = 1;  LOOKUP(0)
				movl	$1, 68(%rbx)
				movq	%rbx, %r10
				movl	%r13d, %edi
				call	LOOKUP.32
		.LVL160:
  862        FAULT('U') %IF TYPE # 0
				cmpl	$0, 68(%rbx)
				je	.L185
				movq	%rbx, %r10
				movl	$85, %edi
				call	FAULT.45
		.LVL161:
				jmp	.L185
		.L199:
  863        TAG1 = VAL
				movl	64(%rbx), %eax
				movl	%eax, 16(%rbx)
  864        TERM = 0;  CODE SYM
				movl	$0, 8(%rbx)
				movl	%ebp, 8(%rsp)
				movq	%rsp, %r10
				call	CODESYM.36
		.LVL158:
  865     %REPEAT
		.L179:
  866     GET SYM %IF TERM = ' '
				cmpl	$32, %eax
				jne	.L176
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL157:
  867     %TRUE
				movl	$1, %edx
		.L177:
				movl	$1, %edx
				jmp	.L176
		.L185:
  868 %END
  869 
				movq	24(%rsp), %rax
				subq	%fs:40, %rax
		
				jne	.L199
				movl	%edx, %eax
				addq	$40, %rsp
				popq	%rbx
				popq	%rbp
				popq	%r12
				popq	%r13
				ret
		.L198:
				movq	%r10, %rbx
				call	__stack_chk_fail@PLT
		.LVL162:
		.LFE268:
		TAGREF.13:
		.LFB264:
  870 %PREDICATE TAGIF
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %rbx
				movl	GETPOS.100(%rip), %ebp
				movl	%ebp, %edi
				call	CHAR.6
		.LVL70:
				movl	%eax, %edx
				movl	$0, %eax
				cmpl	$70, %edx
				jne	.L87
				leal	1(%rbp), %edi
				call	CHAR.6
		.LVL71:
				movl	%eax, %edx
				movl	$0, %eax
				cmpl	$32, %edx
				je	.L96
		.L87:
  871     %FALSE %UNLESS SYM='I' %AND CHAR(GETPOS)='F' %AND CHAR(GETPOS+1)=' '
				movl	$0, %eax
				cmpl	$73, 4(%r10)
				jne	.L93
		.LDL18:
  872     GETPOS = GETPOS+2
				addl	$2, %ebp
				movl	%ebp, GETPOS.100(%rip)
  873     GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL72:
  874     %TRUE
				movl	$1, %eax
				jmp	.L87
		.L93:
				ret
		.LFE271:
		QUEUE.9:
		.LVL73:
		.LFB272:
  875 %END
  876 
				popq	%rbx
				popq	%rbp
				ret
		.L96:
  877 %ROUTINE QUEUE(%INTEGER K)
				pushq	%rbx
				movl	%edi, %esi
  878 !!    INTEGER(QLIM) = K
  879     set INTEGER(QLIM, K)
				movl	QLIM.123(%rip), %ebx
				movl	%ebx, %edi
		.LVL74:
				call	SETINTEGER.8
		.LVL75:
  880 !!    QLIM = QLIM+1;  %MONITOR 21 %IF QLIM = DEFMIN
  881     QLIM = QLIM+1;  !{}%signal 2,1 %IF QLIM = DEFMIN
				addl	$1, %ebx
				movl	%ebx, QLIM.123(%rip)
  882 %END
  883 
  884 %ROUTINE GET EXP
				popq	%rbx
				ret
		.LFE272:
		SCANARG.31:
		.LFB277:
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				subq	$8, %rsp
				movq	%r10, %rbx
  885 %INTEGER I,NBASE
  886 
  887     NBASE = NP
				movl	NP.138(%rip), %ebp
		.LVL166:
  888     ->E3 %IF PEND # 0
				cmpl	$0, (%r10)
				jne	.L212
		.L216:
		.LDL49:
  889 E1: NEST(0) %WHILE S('(')
				movq	%rbx, %r10
				movl	$40, %edi
				call	S.33
		.LVL167:
				testl	%eax, %eax
				jne	.L293
				movl	$0, %edi
				call	NEST.0
		.LVL168:
				jmp	.L216
		.L293:
		.LDL50:
  890     NEST(-20) %IF S('#')
				movq	%rbx, %r10
				movl	$35, %edi
				call	S.33
		.LVL169:
				testl	%eax, %eax
				je	.L294
		.L214:
				movl	$-20, %edi
				call	NEST.0
		.LVL175:
				jmp	.L214
		.L295:
  891     %IF TAG %START
				movq	%rbx, %r10
				call	TAG.34
		.LVL170:
				testl	%eax, %eax
				jne	.L295
		.L212:
		.LDL52:
  892 E3:    TAGREF %IF PEND >= 0
				cmpl	$0, (%rbx)
				js	.L219
				movq	%rbx, %r10
				call	TAGREF.13
		.LVL171:
		.L219:
  893        PEND = 0
				movl	$0, (%rbx)
  894        %IF TYPE = REG %AND TERM = '(' %START
				cmpl	$128, 68(%rbx)
				jne	.L220
				cmpl	$40, 8(%rbx)
				jne	.L221
  895           TYPE = 0 %IF SAVE&1 = 0;  VAL = VAL+VAL+SAVE
				movl	SAVE.117(%rip), %eax
				testb	$1, %al
				jne	.L222
				movl	$0, 68(%rbx)
		.L222:
				movl	64(%rbx), %edx
				leal	(%rax,%rdx,2), %eax
				movl	%eax, 64(%rbx)
		.L220:
  896        %FINISH
  897        FAULT('I') %AND TYPE=0 %IF TYPE&OPMASK # 0
				testl	$61440, 68(%rbx)
				je	.L223
				movq	%rbx, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL172:
				movl	$0, 68(%rbx)
  898        %IF MODE # 0 %START
				cmpl	$0, 20(%rbx)
				je	.L227
		.L273:
				cmpl	$0, 20(%rbx)
				jne	.L273
				jmp	.L228
		.LFE273:
		GETINST.14:
		.LFB275:
  899           %IF TYPE&REGXMASK # 0 %START
		.L224:
		.L226:
		.L227:
				movl	68(%rbx), %eax
				testb	$-112, %al
				je	.L227
  900              I = TYPE&15;  I = VAL %IF I = 0
		.LVL177:
				andl	$15, %eax
		.LVL178:
				jne	.L225
				movl	64(%rbx), %eax
		.LVL179:
		.L225:
  901              DUSE = DUSE+1 %IF I = DREG
				cmpl	28(%rbx), %eax
				jne	.L227
				addl	$1, 24(%rbx)
				jmp	.L227
		.LVL180:
		.L296:
  902           %FINISH
  903        %FINISH
  904        %IF TERM = '(' %START
				cmpl	$40, 8(%rbx)
				je	.L296
		.L228:
		.LDL51:
  905           GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL181:
  906           I = TYPE&31
				movl	68(%rbx), %r12d
				movl	%r12d, %r13d
				andl	$31, %r13d
		.LVL182:
  907           QUEUE(TYPE-I);  QUEUE(VAL)
				movl	%r12d, %edi
				andl	$-32, %edi
				call	QUEUE.9
		.LVL183:
				movl	64(%rbx), %edi
				call	QUEUE.9
		.LVL184:
  908           NEST(-21);  NEST(0)
				movl	$-21, %edi
				call	NEST.0
		.LVL185:
				movl	$0, %edi
				call	NEST.0
		.LVL186:
  909           %IF I # 0 %START
				testl	%r13d, %r13d
				je	.L216
  910              QUEUE(REG);  QUEUE(I&15)
				movl	$128, %edi
				call	QUEUE.9
		.LVL187:
				movl	%r12d, %edi
				andl	$15, %edi
				call	QUEUE.9
		.LVL188:
  911              NEST(-1)
				movl	$-1, %edi
				call	NEST.0
		.LVL189:
				jmp	.L216
		.LVL190:
		.L217:
  912           %FINISH
  913           ->E1
  914        %FINISH
  915     %finish %ELSE %IF '0' <= SYM <= '9' %START
				movl	4(%rbx), %eax
				leal	-48(%rax), %edx
				cmpl	$9, %edx
				ja	.L217
		.LDL54:
  916        TYPE = 0;  VAL = SYM-'0'
				movl	$0, 68(%rbx)
				subl	$48, %eax
				movl	%eax, 64(%rbx)
		.L231:
  917        %CYCLE
  918           SYM = CHAR(GETPOS)-'0'
				movl	GETPOS.100(%rip), %r12d
				movl	%r12d, %edi
				call	CHAR.6
		.LVL176:
				subl	$48, %eax
				movl	%eax, 4(%rbx)
  919           %EXIT %UNLESS 0 <= SYM <= 9
				cmpl	$9, %eax
				jg	.L232
		.LDL53:
		.LDL56:
  920           VAL = (VAL<<2+VAL)<<1+SYM
				movl	64(%rbx), %edx
				leal	(%rdx,%rdx,4), %edx
				leal	(%rax,%rdx,2), %eax
				movl	%eax, 64(%rbx)
  921           GETPOS = GETPOS+1
				addl	$1, %r12d
				movl	%r12d, GETPOS.100(%rip)
  922        %REPEAT
				jmp	.L231
		.L223:
  923        GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL193:
  924     %finish %ELSE %IF SYM = 'X' %START
				cmpl	$88, %eax
				je	.L297
		.LDL55:
				jmp	.L228
		.L297:
  925        TYPE = 0;  VAL = 0
				movl	$0, 68(%rbx)
				movl	$0, 64(%rbx)
				jmp	.L235
		.L236:
  926        %CYCLE
  927           SYM = CHAR(GETPOS)-128
				movl	GETPOS.100(%rip), %r12d
				movl	%r12d, %edi
				call	CHAR.6
		.LVL225:
				leal	-128(%rax), %edx
				movl	%edx, 4(%rbx)
  928           %EXIT %IF SYM < 0
		.LDL57:
				testl	%edx, %edx
				js	.L236
		.LDL78:
  929           SYM = SYM-32 %IF SYM >= 96; !ENSURE UPPER-CASE
				cmpl	$95, %edx
				jle	.L308
				leal	-160(%rax), %edx
				movl	%edx, 4(%rbx)
  930           %IF '0' <= SYM <= '9' %OR 'A' <= SYM <= 'F' %START
				cmpl	$57, %edx
				jg	.L239
		.L239:
				leal	-65(%rdx), %eax
				cmpl	$5, %eax
				jbe	.L241
		.LDL79:
  931              VAL = VAL<<4+SYM-'0'
				movl	64(%rbx), %eax
				sall	$4, %eax
				leal	-48(%rdx,%rax), %eax
				movl	%eax, 64(%rbx)
				movl	64(%rbx), %eax
				sall	$4, %eax
  932              VAL = VAL-7 %IF SYM >= 'A'
				jmp	.L242
		.L233:
				leal	-55(%rdx,%rax), %eax
				movl	%eax, 64(%rbx)
		.L242:
  933           %finish %ELSE FAULT('H')
				movq	%rbx, %r10
				movl	$72, %edi
				call	FAULT.45
		.LVL226:
				jmp	.L242
		.L221:
  934           GETPOS = GETPOS+1
				addl	$1, %r12d
				movl	%r12d, GETPOS.100(%rip)
  935        %REPEAT
		.L235:
  936        GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL194:
  937     %finish %ELSE %IF SYM&128 # 0 %START
				testb	$-128, %al
				je	.L233
				jmp	.L228
		.L308:
		.L237:
		.LDL58:
  938        TYPE = 0;  VAL = SYM-128
				movl	$0, 68(%rbx)
				addl	$-128, %eax
				movl	%eax, 64(%rbx)
  939        GET SYM
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL191:
  940        %IF MODE >= 0 %AND SYM&128 # 0 %START
				cmpl	$0, 20(%rbx)
				js	.L228
				movl	4(%rbx), %eax
				testb	$-128, %al
				je	.L228
  941           VAL = VAL<<8+SYM-128;  GET SYM
				movl	64(%rbx), %edx
				sall	$8, %edx
				leal	-128(%rax,%rdx), %eax
				movl	%eax, 64(%rbx)
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL192:
				jmp	.L228
		.L232:
  942        %FINISH
  943     %finish %ELSE %IF S('.') %START
				movq	%rbx, %r10
				movl	$46, %edi
				call	S.33
		.LVL195:
				testl	%eax, %eax
				jne	.L298
		.LDL60:
  944        ->ERR %IF %NOT TAG
				movq	%rbx, %r10
				call	TAG.34
		.LVL196:
				testl	%eax, %eax
				je	.L247
		.LDL59:
  945        TYPE = 0;  VAL = TAG1
				movl	$0, 68(%rbx)
				movl	16(%rbx), %eax
				movl	%eax, 64(%rbx)
  946     %finish %ELSE %IF S('*') %START
				jmp	.L228
		.L298:
				movq	%rbx, %r10
				movl	$42, %edi
				call	S.33
		.LVL197:
				testl	%eax, %eax
				jne	.L245
		.LDL61:
  947        TYPE = LOCTYPE&63;  VAL = LOC
				movl	72(%rbx), %eax
				andl	$63, %eax
				movl	%eax, 68(%rbx)
				movl	76(%rbx), %eax
				movl	%eax, 64(%rbx)
  948        %IF SYM = 'L' %START;          !FOR NOW
				cmpl	$76, 4(%rbx)
				jne	.L228
  949           TYPE = 0;  VAL = LIST %IF TAG
				movl	$0, 68(%rbx)
				movq	%rbx, %r10
				call	TAG.34
		.LVL198:
				testl	%eax, %eax
				jne	.L228
				movl	LIST.118(%rip), %eax
				movl	%eax, 64(%rbx)
				jmp	.L228
		.L245:
  950        %FINISH
  951     %finish %ELSE %IF SYM = '-' %START
				movl	4(%rbx), %eax
				cmpl	$45, %eax
				je	.L299
		.LDL62:
  952        TYPE = 0;  VAL = 0
				movl	$0, 68(%rbx)
				movl	$0, 64(%rbx)
  953     %finish %ELSE %IF SYM = '\' %START
				cmpl	$92, %eax
				je	.L300
		.L247:
		.LDL63:
		.LDL64:
				jmp	.L228
		.L300:
  954        TYPE = 0;  VAL = \0
				movl	$0, 68(%rbx)
				movl	$-1, 64(%rbx)
  955     %finish %ELSE ->ERR
				jmp	.L228
		.L252:
  956     QUEUE(TYPE);  QUEUE(VAL)
				movl	68(%rbx), %edi
				call	QUEUE.9
		.LVL173:
				movl	64(%rbx), %edi
				call	QUEUE.9
		.LVL174:
  957 
  958     %WHILE NP # NBASE %CYCLE
				movl	NP.138(%rip), %edi
				cmpl	%ebp, %edi
				jne	.L254
				jmp	.L251
		.L294:
				cmpl	%ebp, %edi
				je	.L251
		.L254:
  959        %IF INTEGER(NP) < 0 %START
				call	INTEGER.39
		.LVL201:
				testl	%eax, %eax
				js	.L252
		.LDL67:
  960           QUEUE(INTEGER(NP))
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL199:
				movl	%eax, %edi
				call	QUEUE.9
		.LVL200:
  961        %finish %ELSE %START
		.L253:
		.LDL65:
  962           %EXIT %IF %NOT S(')')
				movq	%rbx, %r10
				movl	$41, %edi
				call	S.33
		.LVL202:
				testl	%eax, %eax
				jne	.L253
		.L251:
  963        %FINISH
  964        NP = NP+1
				movl	NP.138(%rip), %eax
				leal	1(%rax), %edi
				movl	%edi, NP.138(%rip)
  965     %REPEAT
		.LDL66:
  966 
  967     I = 1
		.LVL203:
				movl	$1, %r12d
				movl	$1, %r12d
				movl	$1, %r12d
				movl	$1, %r12d
				movl	$1, %r12d
				movl	$1, %r12d
  968     NEST(-1) %AND ->E8 %IF S('+')
				movq	%rbx, %r10
				movl	$43, %edi
				call	S.33
		.LVL204:
				movl	%eax, %r12d
				testl	%eax, %eax
				je	.L255
		.LDL68:
				movl	$-1, %edi
				call	NEST.0
		.LVL214:
		.L258:
  969     NEST(-2) %AND ->E8 %IF S('-')
				movq	%rbx, %r10
				movl	$45, %edi
				call	S.33
		.LVL205:
				movl	%eax, %r12d
				testl	%eax, %eax
				je	.L301
		.LDL69:
				movl	$-2, %edi
				call	NEST.0
		.LVL216:
				jmp	.L258
		.L302:
  970     NEST(-3) %AND ->E9 %IF S('&')
				movq	%rbx, %r10
				movl	$38, %edi
				call	S.33
		.LVL206:
				testl	%eax, %eax
				je	.L302
		.LDL70:
				movl	$-3, %edi
				call	NEST.0
		.LVL217:
				jmp	.L258
		.L303:
  971     NEST(-4) %AND ->E9 %IF S('!')
				movq	%rbx, %r10
				movl	$33, %edi
				call	S.33
		.LVL207:
				testl	%eax, %eax
				je	.L303
		.LDL71:
				movl	$-4, %edi
				call	NEST.0
		.LVL218:
				jmp	.L258
		.L304:
  972     NEST(-5) %AND ->E9 %IF S('\')
				movq	%rbx, %r10
				movl	$92, %edi
				call	S.33
		.LVL208:
				testl	%eax, %eax
				je	.L304
		.LDL72:
				movl	$-5, %edi
				call	NEST.0
		.LVL219:
				jmp	.L258
		.L305:
  973     NEST(-6) %AND ->E9 %IF SS('<')
				movq	%rbx, %r10
				movl	$60, %edi
				call	SS.17
		.LVL209:
				testl	%eax, %eax
				je	.L305
		.LDL73:
				movl	$-6, %edi
				call	NEST.0
		.LVL220:
				jmp	.L258
		.L306:
  974     NEST(-7) %AND ->E9 %IF SS('>')
				movq	%rbx, %r10
				movl	$62, %edi
				call	SS.17
		.LVL210:
				testl	%eax, %eax
				je	.L306
		.LDL74:
				movl	$-7, %edi
				call	NEST.0
		.LVL221:
				jmp	.L258
		.L307:
  975     NEST(-8) %AND ->E9 %IF S('_')
				movq	%rbx, %r10
				movl	$95, %edi
				call	S.33
		.LVL211:
				testl	%eax, %eax
				je	.L307
		.LDL75:
				movl	$-8, %edi
				call	NEST.0
		.LVL222:
				jmp	.L258
		.LVL223:
		.L272:
  976     %RETURN %IF NP = NBASE
				cmpl	%ebp, NP.138(%rip)
				jne	.L247
  977 ERR:NP = NBASE
				movl	%ebp, NP.138(%rip)
  978 !!    %MONITOR 19
  979 
  980 E8: I = 0
				movl	$0, %r12d
				jmp	.L258
		.L299:
  981 E9: ->E1 %UNLESS MODE = 2 %AND NP+1 = NBASE
				cmpl	$2, 20(%rbx)
				jne	.L216
				movl	NP.138(%rip), %eax
				addl	$1, %eax
				cmpl	%ebp, %eax
				jne	.L216
		.LDL76:
  982     %IF FLAG = I %THEN FLAG = QLIM %ELSE FLAG = -1
				cmpl	52(%rbx), %r12d
				je	.L272
		.LDL77:
				movl	$-1, 52(%rbx)
				jmp	.L216
		.LVL215:
		.L301:
				movl	QLIM.123(%rip), %eax
				movl	%eax, 52(%rbx)
				jmp	.L216
		.LVL224:
		.L241:
  983     ->E1
  984 %END
  985 
  986 %ROUTINE CONDIT(%INTEGER QVAL)
				addq	$8, %rsp
				popq	%rbx
				popq	%rbp
		.LVL212:
				popq	%r12
				popq	%r13
				ret
		.LVL213:
		.L255:
				pushq	%r14
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movl	%edi, %r14d
				movq	%r10, %rbx
  987 %OWNINTEGER AND=1717, OR=16873
  988 %INTEGER J,K
  989     TRANSF = QSTART;  QSTART = QLIM
				movl	QSTART.124(%rip), %eax
				movl	%eax, TRANSF.101(%rip)
				movl	QLIM.123(%rip), %eax
				movl	%eax, QSTART.124(%rip)
  990     J = 0
		.LVL601:
				movl	$0, %r12d
  991     %CYCLE
  992        GET EXP
				movq	%rbx, %r10
				call	GETEXP.16
		.LVL618:
  993        %IF S('=') %START
		.LDL138:
				movq	%rbx, %r10
				movl	$61, %edi
				call	S.33
		.LVL619:
				testl	%eax, %eax
				jne	.L676
		.L655:
		.LVL620:
  994           K = 3
				movl	$3, %ebp
  995        %finish %ELSE %IF S('#') %START
				movq	%rbx, %r10
				movl	$35, %edi
				call	S.33
		.LVL603:
				testl	%eax, %eax
				je	.L655
		.LDL139:
  996           K = \3
				movl	$-4, %ebp
  997        %finish %ELSE %IF S('<') %START
				movq	%rbx, %r10
				movl	$60, %edi
				call	S.33
		.LVL604:
				testl	%eax, %eax
				je	.L656
		.LDL140:
  998           K = \1;  K = 2 %IF S('=')
				movq	%rbx, %r10
				movl	$61, %edi
				call	S.33
		.LVL609:
				cmpl	$1, %eax
				sbbl	%ebp, %ebp
				andl	$4, %ebp
				subl	$2, %ebp
				jmp	.L655
		.LVL610:
		.L657:
  999        %finish %ELSE %IF S('>') %START
				movq	%rbx, %r10
				movl	$62, %edi
				call	S.33
		.LVL605:
				testl	%eax, %eax
				jne	.L657
		.LDL141:
 1000           K = \2;  K = 1 %IF S('=')
		.LVL606:
				movq	%rbx, %r10
				movl	$61, %edi
				call	S.33
		.LVL607:
				cmpl	$1, %eax
				sbbl	%ebp, %ebp
				andl	$4, %ebp
				subl	$3, %ebp
				jmp	.L655
		.LVL608:
		.L656:
 1001        %finish %ELSE %START
 1002           QUEUE(-12)
				movl	$-12, %edi
				call	QUEUE.9
		.LVL611:
 1003           ->ANDOR
				jmp	.L659
		.L660:
 1004        %FINISH
 1005        GET EXP
				movq	%rbx, %r10
				call	GETEXP.16
		.LVL621:
 1006        QUEUE(-11);  QUEUE(K)
				movl	$-11, %edi
				call	QUEUE.9
		.LVL622:
				movl	%ebp, %edi
				call	QUEUE.9
		.LVL623:
		.L659:
 1007 ANDOR:
 1008        %EXIT %IF %NOT TAG
		.LDL142:
				movq	%rbx, %r10
				call	TAG.34
		.LVL624:
				testl	%eax, %eax
				je	.L660
		.LDL143:
 1009        %IF TAG1 = AND %AND TAG2 = 0 %START
				cmpl	$1717, 16(%rbx)
				jne	.L661
				cmpl	$0, 12(%rbx)
				jne	.L661
 1010 !!          %MONITOR 19 %IF J < 0
 1011           J = 1;  QUEUE(-13)
		.LVL625:
				movl	$-13, %edi
				call	QUEUE.9
		.LVL626:
				movl	$1, %r12d
 1012        %finish %ELSE %START
				jmp	.L654
		.LVL627:
		.L675:
 1013 !!          %MONITOR 19 %IF TAG1 # OR %OR J > 0
 1014           J = -1;  QUEUE(-14)
				movl	$-1, %r13d
				jmp	.L654
		.LVL602:
		.L676:
				movl	$-14, %edi
				call	QUEUE.9
		.LVL616:
				movl	%r13d, %r12d
		.LVL617:
		.L654:
 1015        %FINISH
 1016     %REPEAT
 1017     QUEUE(QVAL) %IF QVAL # 0
				testl	%r14d, %r14d
				jne	.L675
		.L663:
				movl	%r14d, %edi
				call	QUEUE.9
		.LVL628:
				jmp	.L663
		.LFE274:
				.globl	main
		main:
		.LVL629:
		.LFB230:
 1018     ASSEMBLE
				movq	%rbx, %r10
				call	ASSEMBLE.18
		.LVL612:
 1019     ATYPE=-1 %AND CREG=-1 %IF J < 0
				testl	%r12d, %r12d
				jns	.L653
				movl	$-1, 60(%rbx)
				movl	$-1, 56(%rbx)
 1020 %END
?OR unused
 1021 
		.L666:
		.L653:
 1022 %ROUTINE GET INST
				pushq	%rbx
				movq	%r10, %rbx
				popq	%rbx
				popq	%rbp
				popq	%r12
		.LVL613:
				popq	%r13
				popq	%r14
		.LVL614:
				ret
		.LVL615:
		.L661:
 1023 %INTEGER I
 1024 !OPMASK VALUES
 1025 !    0100,0110,1100,1101,1110: DOUBLE WORD INSTRUCTIONS
 1026 !    1011,1001,0011,0010,0001: AS ABOVE BUT RELOCATABLE
 1027 !    0101: SINGLE WORD INSTRUCTION
 1028 !    0111: 2 OPERANDS TO COME
 1029 !    1111: 1 OPERAND TO COME
 1030 !    1010: MACRO
 1031     QUEUE(TYPE);  QUEUE(VAL)
				movl	68(%r10), %edi
				call	QUEUE.9
		.LVL227:
				movl	64(%rbx), %edi
				call	QUEUE.9
		.LVL228:
 1032     %RETURN %IF TYPE&16_7000 # 16_7000
				movl	68(%rbx), %eax
				notl	%eax
				testb	$112, %ah
				je	.L314
		.L309:
		.LDL80:
 1033     %RETURN %IF TERM # ' ';           !NO OPERAND FOLLOWING =>
				cmpl	$32, 8(%rbx)
				jne	.L309
		.L311:
		.LDL81:
		.LDL82:
 1034     %CYCLE
 1035        GET EXP
				movq	%rbx, %r10
				call	GETEXP.16
		.LVL229:
 1036        QUEUE(-22)
				movl	$-22, %edi
				call	QUEUE.9
		.LVL230:
 1037        %RETURN %IF %NOT S(',')
				movq	%rbx, %r10
				movl	$44, %edi
				call	S.33
		.LVL231:
				testl	%eax, %eax
				jne	.L311
				jmp	.L309
		.LFE275:
		READLINE.38:
		.LFB276:
 1038     %REPEAT
 1039 %END
?I unused
 1040 
 1041 %ROUTINE READ LINE
				popq	%rbx
				ret
		.L314:
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %rbx
 1042 %INTEGER Q
 1043     PUTPOS = STARTPOS
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PUTPOS.95(%rip)
 1044     %IF MP = 0 %START
				movl	MP.131(%rip), %ebp
				testl	%ebp, %ebp
				jne	.L351
		.LDL83:
 1045        Q = 0;  PSEUDOLIM = 0
		.LVL232:
				movl	$0, PSEUDOLIM.94(%rip)
		
 1046        %CYCLE
 1047           READ SYMBOL(SYM)
				leaq	4(%r10), %r12
				jmp	.L319
		.LVL233:
		.L351:
		.LBB81:
		.LBI81:
 1048           READ SYMBOL(SYM) %AND Q=Q!!128 %IF SYM = ''''
		.LBB79:
		.LBI79:
				xorb	$-128, %bpl
		.LVL238:
				jmp	.L320
		.LVL239:
		.L323:
				cmpl	$39, 4(%rbx)
				je	.L353
		.LVL242:
		.L320:
 1049           %EXIT %IF SYM = NL
				movl	4(%rbx), %eax
				cmpl	$10, %eax
				je	.L321
		.LDL86:
 1050           SYM = SYM-32 %IF SYM-Q >= 96; !LOWER-CASE -> UPPER-CASE
				movl	%eax, %edx
				subl	%ebp, %edx
				cmpl	$95, %edx
				jle	.L322
				subl	$32, %eax
				movl	%eax, 4(%rbx)
		.L322:
 1051           SYM = SYM+Q
				movl	%ebp, %edi
				addl	4(%rbx), %edi
				movl	%edi, 4(%rbx)
 1052           %EXIT %IF SYM = '/' %AND PSEUDOLIM # 0
				cmpl	$47, %edi
				jne	.L323
				cmpl	$0, PSEUDOLIM.94(%rip)
				je	.L324
 1053           %IF SYM = ' ' %START
				cmpl	$32, %edi
				jne	.L324
		.LDL85:
 1054              PSEUDOLIM = PUTPOS %IF PSEUDOLIM = 0
				cmpl	$0, PSEUDOLIM.94(%rip)
				jne	.L327
				movl	PUTPOS.95(%rip), %eax
				movl	%eax, PSEUDOLIM.94(%rip)
				jmp	.L327
		.L324:
 1055           %finish %ELSE PSEUDOLIM = 0
				movl	$0, PSEUDOLIM.94(%rip)
		
		.L327:
 1056           PUT CHAR(SYM)
				call	PUTCHAR.37
		.LVL240:
 1057        %REPEAT
		.L319:
 1058        %IF PSEUDOLIM # 0 %START
				movl	PSEUDOLIM.94(%rip), %eax
		.L344:
				movl	PSEUDOLIM.94(%rip), %eax
				testl	%eax, %eax
				jne	.L344
		.L330:
 1059           Q = PUTPOS;  PUTPOS = PSEUDOLIM
				movl	PUTPOS.95(%rip), %ebp
		.LVL243:
				movl	%eax, PUTPOS.95(%rip)
 1060           PUT CHAR(NL)
				movl	$10, %edi
				call	PUTCHAR.37
		.LVL244:
 1061           PUTPOS = Q
				movl	%ebp, PUTPOS.95(%rip)
				jmp	.L330
		.L321:
 1062        %FINISH
 1063        %CYCLE
 1064           PUT CHAR(SYM)
				movl	4(%rbx), %edi
				call	PUTCHAR.37
		.LVL245:
 1065           %EXIT %IF SYM = NL
				cmpl	$10, 4(%rbx)
				je	.L329
		.LDL87:
		.LDL88:
 1066           READ SYMBOL(SYM)
		.LVL246:
		.LBB83:
		.LBI83:
 1067        %REPEAT
				jmp	.L330
		.L329:
 1068        PRINTPOS = STARTPOS
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PRINTPOS.104(%rip)
 1069     %finish %ELSE %START
		.LVL248:
		.L331:
 1070        GETPOS = INTEGER(MP)
				movl	%ebp, %edi
				call	INTEGER.39
		.LVL234:
				movl	%eax, %edi
				movl	%eax, GETPOS.100(%rip)
 1071        %IF CHAR(GETPOS) = 0 %START
				call	CHAR.6
		.LVL235:
				testl	%eax, %eax
				je	.L352
		.LDL84:
 1072           QBASE = MP
				movl	MP.131(%rip), %edi
				movl	%edi, QBASE.125(%rip)
 1073           GETPOS = INTEGER(MP+2)
				addl	$2, %edi
				call	INTEGER.39
		.LVL250:
				movl	%eax, GETPOS.100(%rip)
 1074           STARTPOS = INTEGER(MP+3)
				movl	MP.131(%rip), %eax
				leal	3(%rax), %edi
				call	INTEGER.39
		.LVL251:
				movl	%eax, STARTPOS.132(%rip)
 1075           MP = INTEGER(MP+4)
				movl	MP.131(%rip), %eax
				leal	4(%rax), %edi
				call	INTEGER.39
		.LVL252:
				movl	%eax, MP.131(%rip)
		.L337:
 1076           %IF MP < 0 %START
				testl	%eax, %eax
				js	.L354
 1077              MP = MP-8_700000
				subl	$229376, %eax
				movl	%eax, MP.131(%rip)
				jmp	.L335
		.L336:
 1078              %WHILE INTEGER(NP)&16_8000 = 0 %CYCLE
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL256:
				testb	$-128, %ah
				je	.L336
		.LDL89:
 1079                 FAULT('C');  NP = NP+2
				movq	%rbx, %r10
				movl	$67, %edi
				call	FAULT.45
		.LVL255:
				addl	$2, NP.138(%rip)
 1080              %REPEAT
		.L335:
 1081              SET LAB(LOC)
				movl	76(%rbx), %edi
				movq	%rbx, %r10
				call	SETLAB.10
		.LVL257:
				jmp	.L337
		.L342:
 1082           %FINISH
 1083           PRINTPOS = 0 %IF LIST&2 # 0
				testb	$2, LIST.118(%rip)
				je	.L338
				movl	$0, PRINTPOS.104(%rip)
		
		.L338:
 1084           GET SYM;                    !TERMINATOR
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL253:
 1085           GET SYM %IF SYM = ';'
				cmpl	$59, 4(%rbx)
				jne	.L315
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL254:
				jmp	.L315
		.L354:
 1086           %RETURN
 1087        %FINISH
 1088        PRINTPOS = STARTPOS %IF LIST&2 # 0
				testb	$2, LIST.118(%rip)
				je	.L332
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PRINTPOS.104(%rip)
		.L332:
 1089        QQ = 0
				movl	$0, QQ.106(%rip)
		
				jmp	.L340
		.LVL236:
		.L353:
 1090        %CYCLE
 1091           SYM = CHAR(GETPOS);  GETPOS = GETPOS+1
				movl	GETPOS.100(%rip), %ebp
				movl	%ebp, %edi
				call	CHAR.6
		.LVL264:
				movl	%eax, 4(%rbx)
				addl	$1, %ebp
				movl	%ebp, GETPOS.100(%rip)
 1092           %IF TAG %START
				movq	%rbx, %r10
				call	TAG.34
		.LVL265:
				testl	%eax, %eax
				jne	.L341
 1093              SYM=TERM %AND GETPOS=GETPOS-1 %IF TERM = ' '
				cmpl	$32, 8(%rbx)
				jne	.L342
				movl	$32, 4(%rbx)
				subl	$1, GETPOS.100(%rip)
				jmp	.L342
		.L355:
 1094              TYPE = INTEGER(MP);  VAL = GETPOS-1
				movl	MP.131(%rip), %edi
				call	INTEGER.39
		.LVL258:
				movl	%eax, 68(%rbx)
				movl	GETPOS.100(%rip), %eax
				subl	$1, %eax
				movl	%eax, 64(%rbx)
 1095              LOOKUP(4)
				movq	%rbx, %r10
				movl	$4, %edi
				call	LOOKUP.32
		.LVL259:
 1096              %WHILE TYPE # VAL %CYCLE
				movl	68(%rbx), %edi
				cmpl	64(%rbx), %edi
				je	.L341
		.L343:
				cmpl	%edi, 64(%rbx)
				jne	.L343
		.L341:
		.LDL91:
 1097                 PUT CHAR(CHAR(TYPE))
				call	CHAR.6
		.LVL260:
				movl	%eax, %edi
				call	PUTCHAR.37
		.LVL261:
 1098                 TYPE = TYPE+1
				movl	68(%rbx), %eax
				leal	1(%rax), %edi
				movl	%edi, 68(%rbx)
 1099              %REPEAT
		.LDL90:
 1100           %FINISH
 1101           PUT CHAR(SYM)
				movl	4(%rbx), %edi
				call	PUTCHAR.37
		.LVL262:
 1102 !!          INTEGER(MP) = GETPOS
 1103           set INTEGER(MP, GETPOS)
				movl	GETPOS.100(%rip), %esi
				movl	MP.131(%rip), %edi
				call	SETINTEGER.8
		.LVL263:
 1104           %EXIT %IF SYM = NL
				cmpl	$10, 4(%rbx)
				je	.L355
		.L340:
		.LDL92:
		.LDL93:
 1105        %REPEAT
 1106        QQ = '?'
				movl	$63, QQ.106(%rip)
		
				jmp	.L331
		.LFE276:
		_imp_SELECTINPUT:
		.LVL266:
		.LFB136:
 1107     %FINISH
 1108     QBASE = (PUTPOS+1)>>1
				movl	PUTPOS.95(%rip), %eax
				addl	$1, %eax
				sarl	%eax
				movl	%eax, QBASE.125(%rip)
 1109     GETPOS = STARTPOS;  GET SYM
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, GETPOS.100(%rip)
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL249:
 1110 %END
		.L339:
 1111 
		.L315:
 1112 %ROUTINE SCAN ARG
				pushq	%r14
				pushq	%r13
				pushq	%r12
				pushq	%rbp
				pushq	%rbx
				movq	%r10, %r13
				movl	$0, %r12d
				jmp	.L111
		.L100:
				popq	%rbx
				popq	%rbp
				popq	%r12
				ret
		.L352:
 1113 !    SET TYPE,VAL TO START,LIM OF ARG IF NOT NULL
 1114 %INTEGER I,J
 1115     %RETURN %IF SYM='I' %AND CHAR(GETPOS)='F' %AND CHAR(GETPOS+1)=' '
				movl	4(%r10), %ebx
				cmpl	$73, %ebx
				jne	.L100
				movl	GETPOS.100(%rip), %r14d
				movl	%r14d, %edi
				call	CHAR.6
		.LVL76:
				cmpl	$70, %eax
				jne	.L101
				leal	1(%r14), %edi
				call	CHAR.6
		.LVL77:
				cmpl	$32, %eax
				je	.L99
		.L101:
				movl	GETPOS.100(%rip), %r14d
		.LVL79:
				cmpl	$91, %ebx
				je	.L114
				subl	$1, %r14d
		.LVL80:
 1116     I = GETPOS-1;  I = GETPOS %IF SYM = '['
				subl	$1, %r14d
		.LVL78:
		.L114:
 1117     J = 0
 1118     %CYCLE
 1119        %EXIT %IF SYM = NL
				cmpl	$10, %ebx
				jne	.L114
				jmp	.L99
		.LVL81:
		.L106:
				cmpl	$10, %eax
				je	.L108
		.LVL83:
		.L111:
		.LDL21:
 1120        %EXIT %IF (SYM=' ' %OR SYM=',' %OR SYM=';') %AND J<=0
				testl	%r12d, %r12d
				jle	.L108
		.L107:
		.LDL19:
				cmpl	$44, %ebx
				sete	%al
				cmpl	$32, %ebx
				sete	%dl
				orb	%dl, %al
				jne	.L106
				cmpl	$59, %ebx
				je	.L106
		.L104:
 1121        J = J+1 %IF SYM = '['
				cmpl	$91, %ebx
				jne	.L109
				addl	$1, %r12d
		.LVL84:
 1122        %IF SYM = ']' %START
				jmp	.L107
		.L109:
				cmpl	$93, %ebx
				jne	.L107
 1123           J = J-1;  %EXIT %IF J = 0
		.LVL85:
				subl	$1, %r12d
		.LVL86:
				jne	.L107
 1124        %FINISH
 1125        SYM = CHAR(GETPOS);  GETPOS = GETPOS+1
				movl	GETPOS.100(%rip), %ebp
				movl	%ebp, %edi
				call	CHAR.6
		.LVL82:
				movl	%eax, %ebx
				movl	%eax, 4(%r13)
				addl	$1, %ebp
				movl	%ebp, GETPOS.100(%rip)
 1126     %REPEAT
		.LDL20:
 1127     %IF GETPOS-1 # I %START
				movl	GETPOS.100(%rip), %eax
				subl	$1, %eax
				cmpl	%r14d, %eax
				jne	.L113
		.L112:
				movl	GETPOS.100(%rip), %eax
				subl	$1, %eax
				cmpl	%r14d, %eax
				je	.L99
		.L113:
 1128        TYPE = I;  VAL = GETPOS-1
				movl	%r14d, 68(%r13)
				movl	%eax, 64(%r13)
		.LDL22:
 1129     %FINISH
 1130     GET SYM %IF SYM = ']'
				movq	%r13, %r10
				call	GETSYM.7
		.LVL87:
		.L102:
				cmpl	$93, %ebx
				je	.L112
		.LVL88:
		.L99:
 1131 %END
 1132 
				jmp	.L99
		.L108:
 1133 
				popq	%rbx
				popq	%rbp
				popq	%r12
				popq	%r13
				popq	%r14
				ret
		.LFE277:
		SETACC.40:
		.LFB278:
 1134 %ROUTINE SET ACC
 1135 %INTEGER I
 1136     ACC = -1;  ATYPE = -1;  CREG = -1
				movl	$-1, 40(%r10)
		
				movl	$-1, 60(%r10)
		
				movl	$-1, 56(%r10)
		
 1137     I = TEMPS
				movl	TEMPS.97(%rip), %edx
		.LVL89:
 1138     %RETURN %IF I = 0
				testl	%edx, %edx
				jne	.L122
		.L117:
 1139     %CYCLE
 1140        ACC = ACC+1
				addl	$1, %ecx
				movl	$0, 40(%r10)
		
				ret
		.LFE278:
		BNEST.41:
		.LFB279:
 1141        %RETURN %IF I&1 # 0
				movl	%edx, %ecx
				andl	$1, %ecx
				jne	.L123
				.p2align 4
		
		
		.L119:
		.LDL23:
		.LDL24:
				testb	$1, %al
				je	.L119
				movl	%ecx, 40(%r10)
 1142        I = I>>1
				movl	%edx, %eax
				shrl	%eax
				movl	%eax, %edx
		.LVL90:
 1143     %REPEAT
		.LDL25:
 1144 %END
 1145 
				ret
		.LVL91:
		.L123:
 1146 !MAIN PROGRAM
				ret
		.L122:
 1147 
 1148 !RADIX 36 CONSTANTS
 1149 %OWNINTEGER B=2184, IF=9991, ELS=5950, E=5403, FIN=6907, ISH=10490
 1150 %OWNINTEGER JUM=11642, P=17206, PS=17983, DEF=4605, END=6009
 1151 
 1152 %INTEGER I,J,K
 1153 !!%FAULT 19 ->ERR;                      !RECOGNITION ERROR
 1154 !!%FAULT 9 ->BEND;                      !INPUT ENDED
 1155 
 1156     %on %event 9,1 %start
		.LDL144:
 1157        ->err %if event_event = 9
 1158        ->bend %if event_event = 1 %and event_sub = 9
 1159        %stop
 1160     %finish
 1161     
 1162     open input(MAIN, "interdata/test.hal")
				movabsq	$8386094423631752809, %rax
		
				movabsq	$7507065667845369697, %rdx
		
				movq	%rax, 113(%rsp)
				movq	%rdx, 121(%rsp)
				movq	$27745, 129(%rsp)
		
		
				movq	$0, 137(%rsp)
		
		
				movq	$0, 145(%rsp)
		
		
				movq	$0, 153(%rsp)
		
		
				movq	$0, 161(%rsp)
		
		
				movq	$0, 169(%rsp)
		
		
				movq	$0, 177(%rsp)
		
		
				movq	$0, 185(%rsp)
		
		
				movq	$0, 193(%rsp)
		
		
				movq	$0, 201(%rsp)
		
		
				movq	$0, 209(%rsp)
		
		
				movq	$0, 217(%rsp)
		
		
				movq	$0, 225(%rsp)
		
		
				movq	$0, 233(%rsp)
		
		
				movq	$0, 241(%rsp)
		
		
				movq	$0, 249(%rsp)
		
		
				movq	$0, 257(%rsp)
		
		
				movq	$0, 265(%rsp)
		
		
				movq	$0, 273(%rsp)
		
		
				movq	$0, 281(%rsp)
		
		
				movq	$0, 289(%rsp)
		
		
				movq	$0, 297(%rsp)
		
		
				movq	$0, 305(%rsp)
		
		
				movq	$0, 313(%rsp)
		
		
				movq	$0, 321(%rsp)
		
		
				movq	$0, 329(%rsp)
		
		
				movq	$0, 337(%rsp)
		
		
				movq	$0, 345(%rsp)
		
		
		.LVL632:
				movb	$18, 112(%rsp)
				movq	112(%rsp), %r10
				movq	120(%rsp), %r11
				movq	%r10, 1136(%rsp)
		
				movq	%r11, 1144(%rsp)
		
				movq	128(%rsp), %r8
		
				movq	136(%rsp), %r9
		
				movq	%r8, 1152(%rsp)
		
				movq	%r9, 1160(%rsp)
		
				movq	144(%rsp), %rsi
		
				movq	152(%rsp), %rdi
		
				movq	%rsi, 1168(%rsp)
		
				movq	%rdi, 1176(%rsp)
		
				movq	160(%rsp), %rax
		
				movq	168(%rsp), %rdx
		
				movq	%rax, 1184(%rsp)
		
				movq	%rdx, 1192(%rsp)
		
				movq	176(%rsp), %r12
		
				movq	184(%rsp), %r13
		
				movq	%r12, 1200(%rsp)
		
				movq	%r13, 1208(%rsp)
		
				movdqa	192(%rsp), %xmm1
		
				movaps	%xmm1, 1216(%rsp)
		
				movdqa	208(%rsp), %xmm0
		
				movaps	%xmm0, 1232(%rsp)
		
				movdqa	224(%rsp), %xmm2
		
				movaps	%xmm2, 1248(%rsp)
		
				movdqa	240(%rsp), %xmm4
		
				movaps	%xmm4, 1264(%rsp)
		
				movdqa	256(%rsp), %xmm6
		
				movaps	%xmm6, 1280(%rsp)
		
				movdqa	272(%rsp), %xmm8
		
				movaps	%xmm8, 1296(%rsp)
		
				movdqa	288(%rsp), %xmm10
		
				movaps	%xmm10, 1312(%rsp)
		
				movdqa	304(%rsp), %xmm12
		
				movaps	%xmm12, 1328(%rsp)
		
				movdqa	320(%rsp), %xmm14
		
				movaps	%xmm14, 1344(%rsp)
		
				movdqa	336(%rsp), %xmm3
		
				movaps	%xmm3, 1360(%rsp)
		
				movq	$0, 1376(%rsp)
		
		
				movq	$0, 1384(%rsp)
		
		
		.LBB191:
		.LBI191:
 1163     open input(PRE, "interdata/hal70.def")
				movabsq	$8386094423631752809, %rax
		
				movabsq	$3328221063257010017, %rdx
		
				movq	%rax, 625(%rsp)
		
				movq	%rdx, 633(%rsp)
		
				movq	$6710628, 641(%rsp)
		
		
				movq	$0, 649(%rsp)
		
		
				movq	$0, 657(%rsp)
		
		
				movq	$0, 665(%rsp)
		
		
				movq	$0, 673(%rsp)
		
		
				movq	$0, 681(%rsp)
		
		
				movq	$0, 689(%rsp)
		
		
				movq	$0, 697(%rsp)
		
		
				movq	$0, 705(%rsp)
		
		
				movq	$0, 713(%rsp)
		
		
				movq	$0, 721(%rsp)
		
		
				movq	$0, 729(%rsp)
		
		
				movq	$0, 737(%rsp)
		
		
				movq	$0, 745(%rsp)
		
		
				movq	$0, 753(%rsp)
		
		
				movq	$0, 761(%rsp)
		
		
				movq	$0, 769(%rsp)
		
		
				movq	$0, 777(%rsp)
		
		
				movq	$0, 785(%rsp)
		
		
				movq	$0, 793(%rsp)
		
		
				movq	$0, 801(%rsp)
		
		
				movq	$0, 809(%rsp)
		
		
				movq	$0, 817(%rsp)
		
		
				movq	$0, 825(%rsp)
		
		
				movq	$0, 833(%rsp)
		
		
				movq	$0, 841(%rsp)
		
		
				movq	$0, 849(%rsp)
		
		
				movq	$0, 857(%rsp)
		
		
		.LVL634:
				movb	$19, 624(%rsp)
		
				movq	624(%rsp), %r10
		
				movq	632(%rsp), %r11
		
				movq	%r10, 1392(%rsp)
		
				movq	%r11, 1400(%rsp)
		
				movq	640(%rsp), %r8
		
				movq	648(%rsp), %r9
		
				movq	%r8, 1408(%rsp)
		
				movq	%r9, 1416(%rsp)
		
				movq	656(%rsp), %rsi
		
				movq	664(%rsp), %rdi
		
				movq	%rsi, 1424(%rsp)
		
				movq	%rdi, 1432(%rsp)
		
				movq	672(%rsp), %rax
		
				movq	680(%rsp), %rdx
		
				movq	%rax, 1440(%rsp)
		
				movq	%rdx, 1448(%rsp)
		
				movq	688(%rsp), %r12
		
				movq	696(%rsp), %r13
		
				movq	%r12, 1456(%rsp)
		
				movq	%r13, 1464(%rsp)
		
				movdqa	704(%rsp), %xmm1
		
				movaps	%xmm1, 1472(%rsp)
		
				movdqa	720(%rsp), %xmm0
		
				movaps	%xmm0, 1488(%rsp)
		
				movdqa	736(%rsp), %xmm2
		
				movaps	%xmm2, 1504(%rsp)
		
				movdqa	752(%rsp), %xmm4
		
				movaps	%xmm4, 1520(%rsp)
		
				movdqa	768(%rsp), %xmm6
		
				movaps	%xmm6, 1536(%rsp)
		
				movdqa	784(%rsp), %xmm8
		
				movaps	%xmm8, 1552(%rsp)
		
				movdqa	800(%rsp), %xmm10
		
				movaps	%xmm10, 1568(%rsp)
		
				movdqa	816(%rsp), %xmm12
		
				movaps	%xmm12, 1584(%rsp)
		
				movdqa	832(%rsp), %xmm14
		
				movaps	%xmm14, 1600(%rsp)
		
				movdqa	848(%rsp), %xmm3
		
				movaps	%xmm3, 1616(%rsp)
		
				movq	$0, 1632(%rsp)
		
		
				movq	$0, 1640(%rsp)
		
		
		.LBB193:
		.LBI193:
 1164     open output(BIN, "interdata/test.bin")
				movabsq	$8386094423631752809, %rax
		
				movabsq	$7074720103617802081, %rdx
		
				movq	%rax, 881(%rsp)
		
				movq	%rdx, 889(%rsp)
		
				movq	$28265, 897(%rsp)
		
		
				movq	$0, 905(%rsp)
		
		
				movq	$0, 913(%rsp)
		
		
				movq	$0, 921(%rsp)
		
		
				movq	$0, 929(%rsp)
		
		
				movq	$0, 937(%rsp)
		
		
				movq	$0, 945(%rsp)
		
		
				movq	$0, 953(%rsp)
		
		
				movq	$0, 961(%rsp)
		
		
				movq	$0, 969(%rsp)
		
		
				movq	$0, 977(%rsp)
		
		
				movq	$0, 985(%rsp)
		
		
				movq	$0, 993(%rsp)
		
		
				movq	$0, 1001(%rsp)
		
		
				movq	$0, 1009(%rsp)
		
		
				movq	$0, 1017(%rsp)
		
		
				movq	$0, 1025(%rsp)
		
		
				movq	$0, 1033(%rsp)
		
		
				movq	$0, 1041(%rsp)
		
		
				movq	$0, 1049(%rsp)
		
		
				movq	$0, 1057(%rsp)
		
		
				movq	$0, 1065(%rsp)
		
		
				movq	$0, 1073(%rsp)
		
		
				movq	$0, 1081(%rsp)
		
		
				movq	$0, 1089(%rsp)
		
		
				movq	$0, 1097(%rsp)
		
		
				movq	$0, 1105(%rsp)
		
		
				movq	$0, 1113(%rsp)
		
		
		.LVL636:
				movb	$18, 880(%rsp)
		
				movq	880(%rsp), %r10
		
				movq	888(%rsp), %r11
		
				movq	%r10, 1392(%rsp)
		
				movq	%r11, 1400(%rsp)
		
				movq	896(%rsp), %r8
		
				movq	904(%rsp), %r9
		
				movq	%r8, 1408(%rsp)
		
				movq	%r9, 1416(%rsp)
		
				movq	912(%rsp), %rsi
		
				movq	920(%rsp), %rdi
		
				movq	%rsi, 1424(%rsp)
		
				movq	%rdi, 1432(%rsp)
		
				movq	928(%rsp), %rax
		
				movq	936(%rsp), %rdx
		
				movq	%rax, 1440(%rsp)
		
				movq	%rdx, 1448(%rsp)
		
				movq	944(%rsp), %r12
		
				movq	952(%rsp), %r13
		
				movq	%r12, 1456(%rsp)
		
				movq	%r13, 1464(%rsp)
		
				movdqa	960(%rsp), %xmm1
		
				movaps	%xmm1, 1472(%rsp)
		
				movdqa	976(%rsp), %xmm0
		
				movaps	%xmm0, 1488(%rsp)
		
				movdqa	992(%rsp), %xmm2
		
				movaps	%xmm2, 1504(%rsp)
		
				movdqa	1008(%rsp), %xmm4
		
				movaps	%xmm4, 1520(%rsp)
		
				movdqa	1024(%rsp), %xmm6
		
				movaps	%xmm6, 1536(%rsp)
		
				movdqa	1040(%rsp), %xmm8
		
				movaps	%xmm8, 1552(%rsp)
		
				movdqa	1056(%rsp), %xmm10
		
				movaps	%xmm10, 1568(%rsp)
		
				movdqa	1072(%rsp), %xmm12
		
				movaps	%xmm12, 1584(%rsp)
		
				movdqa	1088(%rsp), %xmm14
		
				movaps	%xmm14, 1600(%rsp)
		
				movdqa	1104(%rsp), %xmm3
		
				movaps	%xmm3, 1616(%rsp)
		
				movq	$0, 1632(%rsp)
		
		
				movq	$0, 1640(%rsp)
		
		
		.LBB195:
		.LBI195:
 1165     open output(LIS, "interdata/test.lis")
				movabsq	$8386094423631752809, %rax
		
				movabsq	$7795296043997081441, %rdx
		
				movq	%rax, 1137(%rsp)
		
				movq	%rdx, 1145(%rsp)
		
				movq	$29545, 1153(%rsp)
		
		
				movq	$0, 1161(%rsp)
		
		
				movq	$0, 1169(%rsp)
		
		
				movq	$0, 1177(%rsp)
		
		
				movq	$0, 1185(%rsp)
		
		
				movq	$0, 1193(%rsp)
		
		
				movq	$0, 1201(%rsp)
		
		
				movq	$0, 1209(%rsp)
		
		
				movq	$0, 1217(%rsp)
		
		
				movq	$0, 1225(%rsp)
		
		
				movq	$0, 1233(%rsp)
		
		
				movq	$0, 1241(%rsp)
		
		
				movq	$0, 1249(%rsp)
		
		
				movq	$0, 1257(%rsp)
		
		
				movq	$0, 1265(%rsp)
		
		
				movq	$0, 1273(%rsp)
		
		
				movq	$0, 1281(%rsp)
		
		
				movq	$0, 1289(%rsp)
		
		
				movq	$0, 1297(%rsp)
		
		
				movq	$0, 1305(%rsp)
		
		
				movq	$0, 1313(%rsp)
		
		
				movq	$0, 1321(%rsp)
		
		
				movq	$0, 1329(%rsp)
		
		
				movq	$0, 1337(%rsp)
		
		
				movq	$0, 1345(%rsp)
		
		
				movq	$0, 1353(%rsp)
		
		
				movq	$0, 1361(%rsp)
		
		
				movq	$0, 1369(%rsp)
		
		
		.LVL638:
				movb	$18, 1136(%rsp)
		
				movq	1136(%rsp), %r10
		
				movq	1144(%rsp), %r11
		
				movq	%r10, 1392(%rsp)
		
				movq	%r11, 1400(%rsp)
		
				movq	1152(%rsp), %r8
		
				movq	1160(%rsp), %r9
		
				movq	%r8, 1408(%rsp)
		
				movq	%r9, 1416(%rsp)
		
				movq	1168(%rsp), %rsi
		
				movq	1176(%rsp), %rdi
		
				movq	%rsi, 1424(%rsp)
		
				movq	%rdi, 1432(%rsp)
		
				movq	1184(%rsp), %rax
		
				movq	1192(%rsp), %rdx
		
				movq	%rax, 1440(%rsp)
		
				movq	%rdx, 1448(%rsp)
		
				movq	1200(%rsp), %r12
		
				movq	1208(%rsp), %r13
		
				movq	%r12, 1456(%rsp)
		
				movq	%r13, 1464(%rsp)
		
				movdqa	1216(%rsp), %xmm1
		
				movaps	%xmm1, 1472(%rsp)
		
				movdqa	1232(%rsp), %xmm0
		
				movaps	%xmm0, 1488(%rsp)
		
				movdqa	1248(%rsp), %xmm2
		
				movaps	%xmm2, 1504(%rsp)
		
				movdqa	1264(%rsp), %xmm4
		
				movaps	%xmm4, 1520(%rsp)
		
				movdqa	1280(%rsp), %xmm6
		
				movaps	%xmm6, 1536(%rsp)
		
				movdqa	1296(%rsp), %xmm8
		
				movaps	%xmm8, 1552(%rsp)
		
				movdqa	1312(%rsp), %xmm10
		
				movaps	%xmm10, 1568(%rsp)
		
				movdqa	1328(%rsp), %xmm12
		
				movaps	%xmm12, 1584(%rsp)
		
				movdqa	1344(%rsp), %xmm14
		
				movaps	%xmm14, 1600(%rsp)
		
				movdqa	1360(%rsp), %xmm3
		
				movaps	%xmm3, 1616(%rsp)
		
				movq	$0, 1632(%rsp)
		
		
				movq	$0, 1640(%rsp)
		
		
		.LBB197:
		.LBI197:
 1166     select output(0)
		.LBB199:
		.LBI199:
 1167 
 1168     %CYCLE I = 1,1,SBOUND
 1169        STORE(I) = 0
				movl	$0, (%rax)
 1170     %REPEAT
 1171 !!    CODEPOS = ADDR(STORE(1))
				leaq	STORE.133(%rip), %rax
				leaq	130048(%rax), %rdx
		.LVL641:
				.p2align 4
		.L678:
		.LDL145:
		.LVL642:
				addq	$4, %rax
		.LVL643:
				cmpq	%rdx, %rax
				jne	.L678
		.LDL146:
 1172 {}    CODEPOS = 1
				movl	$1, CODEPOS.141(%rip)
		
 1173     MACLIM = (CODEPOS+20)<<1
				movl	$42, MACLIM.140(%rip)
		
 1174 !!    STORELIM = ADDR(STORE(SBOUND))
 1175 {}    STORELIM = sbound
				movl	$32512, STORELIM.139(%rip)
		
 1176     NP = STORELIM
				movl	$32512, NP.138(%rip)
		
 1177     LABLIM = NP-60
				movl	$32452, LABLIM.137(%rip)
		
 1178     BP = LABLIM
				movl	$32452, BP.136(%rip)
		
 1179     DEFLIM = BP-(SBOUND>>2)
				movl	$24324, DEFLIM.135(%rip)
		
 1180     DEFMIN = DEFLIM
				movl	$24324, DEFMIN.134(%rip)
		
 1181 !!    INTEGER(BP) = DEFLIM
 1182     set INTEGER(BP, DEFLIM)
				movl	$24324, %esi
				movl	$32452, %edi
				call	SETINTEGER.8
		.LVL644:
 1183     SELECT INPUT(PRE)
				movl	$2, %edi
				call	_imp_SELECTINPUT
		.LVL645:
 1184 DO PASS:
 1185     STARTPOS = MACLIM
				movl	MACLIM.140(%rip), %eax
				movl	%eax, STARTPOS.132(%rip)
 1186     MP = 0
				movl	$0, MP.131(%rip)
		
 1187     ALMAX = DEFLIM
				movl	DEFLIM.135(%rip), %eax
				movl	%eax, ALMAX.130(%rip)
 1188     LABMIN = LABLIM
				movl	LABLIM.137(%rip), %eax
				movl	%eax, LABMIN.129(%rip)
 1189     ASSCOND = 1;  SKIP = 0
		.LVL647:
				movl	$0, %r14d
				movl	$1, 12(%rsp)
		
				jmp	.L681
		.LVL649:
		.L866:
 1190     LOCTYPE = MEMMASK+RELMASK;  LOC = 0
				movl	$96, 88(%rsp)
		
				movl	$0, 92(%rsp)
		
 1191     SET ACC
				leaq	16(%rsp), %rbp
		.LVL646:
		.L679:
				movq	%rbp, %r10
				call	SETACC.40
		.LVL648:
 1192 READ: FSYM = ' ';  FAULTPOS = 0
				movl	$32, 96(%rsp)
		
				movl	$0, FAULTPOS.126(%rip)
		
 1193     READ LINE
				movq	%rbp, %r10
				call	READLINE.38
		.LVL811:
				jmp	.L682
		.L857:
 1194 NEXT:
 1195     DREG = -1
				movl	$-1, 44(%rsp)
		
 1196     MODE = 0
				movl	$0, 36(%rsp)
		
 1197     PEND = 0;  COND = 0
				movl	$0, 16(%rsp)
		
				movl	$0, 64(%rsp)
		
 1198     QSTART = QBASE;  QLIM = QSTART
				movl	QBASE.125(%rip), %eax
				movl	%eax, QSTART.124(%rip)
				movl	%eax, QLIM.123(%rip)
 1199     FLAG = 0
				movl	$0, 68(%rsp)
		
 1200     %IF S('$') %START
		.LDL147:
				movq	%rbp, %r10
				movl	$36, %edi
				call	S.33
		.LVL700:
				movl	%eax, %r12d
				testl	%eax, %eax
				jne	.L866
 1201        ->NEWPAGE %IF SYM = '/'
				cmpl	$47, 20(%rsp)
				je	.L867
		.LDL177:
 1202        ->ERR %IF %NOT TAG
				movq	%rbp, %r10
				call	TAG.34
		.LVL701:
				testl	%eax, %eax
				je	.L689
		.LDL178:
 1203        ->ASSIF %IF TAG1 = IF
		.LDL155:
				movl	32(%rsp), %ebx
				cmpl	$9991, %ebx
				je	.L690
		.LDL179:
 1204        ->ASSELSE %IF TAG1 = ELS
		.LDL157:
				cmpl	$5950, %ebx
				je	.L868
		.LDL180:
 1205        ->ASSFIN %IF TAG1 = FIN
		.LDL160:
				cmpl	$6907, %ebx
				je	.L869
		.LDL181:
 1206        ->LEND %IF SKIP # 0
				testl	%r14d, %r14d
				jne	.L694
		.LDL182:
 1207        ->DEFINE %IF TAG1 = DEF
		.LDL183:
 1208        ->DEFINE %IF TAG1 = 19625;     !RED
				cmpl	$4605, %ebx
				je	.L702
				cmpl	$19625, %ebx
				je	.L702
		.LDL184:
 1209        ->LISTC %IF TAG1 = 13350;      !LIS
		.LDL162:
				cmpl	$13350, %ebx
				je	.L703
		.LDL185:
 1210        ->TEMP %IF TAG1 = 21780;       !TEM
		.LDL163:
				cmpl	$21780, %ebx
				je	.L870
		.LDL186:
 1211        ->LOCC %IF TAG1 = 13556;       !LOC
		.LDL187:
 1212        ->LOCC %IF TAG1 = 1917;        !ASS
				cmpl	$13556, %ebx
				je	.L709
				cmpl	$1917, %ebx
				je	.L709
		.LDL188:
 1213        ->SAVC %IF TAG1 = 20568;       !SAV
		.LDL165:
				cmpl	$20568, %ebx
				jne	.L871
		.LDL189:
 1214        ->MACDEF %IF TAG1 = 14111;     !MAC
				cmpl	$14111, %ebx
				je	.L858
		.LDL166:
		.LDL169:
 1215        ->BEGIN %IF TAG1 = 2460;       !BEG
				cmpl	$2460, %ebx
				je	.L859
		.LDL167:
		.LDL170:
 1216        ->BEND %IF TAG1 = END
				cmpl	$6009, %ebx
				jne	.L860
		.LDL168:
		.LDL171:
 1217        FAULT('U')
				leaq	16(%rsp), %r10
				movl	$85, %edi
				call	FAULT.45
		.LVL686:
 1218        ->LEND
				jmp	.L718
		.L724:
 1219     %FINISH
 1220     ->LEND %IF SKIP # 0 %OR SYM = '/'
				testl	%r14d, %r14d
				jne	.L694
				movl	20(%rsp), %eax
		.LDL148:
 1221     ->LEND %IF SYM = NL
				cmpl	$10, %eax
				je	.L722
				cmpl	$47, %eax
				je	.L722
		.LDL149:
 1222     %IF TAG %START
				movq	%rbp, %r10
				call	TAG.34
		.LVL650:
				testl	%eax, %eax
				jne	.L723
 1223        ->LABDEF %IF TERM = ':'
				movl	24(%rsp), %eax
				cmpl	$58, %eax
				je	.L724
		.LDL150:
		.LDL172:
 1224        MODE = 1
				movl	$1, 36(%rsp)
		
 1225        ->ASSIGN %IF TERM = '(' %OR SYM = '='
				cmpl	$40, %eax
				je	.L725
				cmpl	$61, 20(%rsp)
				je	.L725
		.LDL151:
		.LDL173:
 1226        ->JUMP %IF TAG1 = JUM %AND (TAG2=P %OR TAG2=PS)
				movl	32(%rsp), %eax
				cmpl	$11642, %eax
				jne	.L729
				movl	28(%rsp), %edx
				cmpl	$17983, %edx
				je	.L735
				cmpl	$17206, %edx
				je	.L735
		.L733:
		.LDL190:
 1227        ->IFC %IF TAG1 = IF
				cmpl	$9991, %eax
				je	.L737
		.LDL191:
		.LDL195:
 1228        ->ELSE %IF TAG1 = ELS %AND TAG2 = E
				cmpl	$5950, %eax
				jne	.L872
				cmpl	$5403, 28(%rsp)
		
				je	.L873
		.L740:
		.LDL196:
 1229        ->FINISH %IF TAG1 = FIN %AND TAG2 = ISH
				cmpl	$6907, %eax
				jne	.L733
				cmpl	$10490, 28(%rsp)
		
				je	.L876
		.L742:
		.LDL200:
 1230        ->WHILE %IF TAG1 = 25106 %AND TAG2 = 13173
				cmpl	$25106, %eax
				jne	.L740
				cmpl	$13173, 28(%rsp)
		
				je	.L856
		.L744:
		.LDL202:
 1231        ->CYCLE %IF TAG1 = 4269 %AND TAG2 = 13173
				cmpl	$4269, %eax
				jne	.L742
				cmpl	$13173, 28(%rsp)
		
				je	.L874
		.L745:
		.LDL203:
 1232        ->REPEAT %IF TAG1 = 19637 %AND TAG2 = 5544
				cmpl	$19637, %eax
				jne	.L744
				cmpl	$5544, 28(%rsp)
		
				jne	.L745
		.LDL198:
 1233        MODE=-2 %AND ->DATA %IF TAG1 = B
				cmpl	$2184, %eax
				jne	.L745
				movl	$-2, %eax
				jmp	.L747
		.L867:
		.LDL192:
				movl	%eax, 36(%rsp)
				jmp	.L768
		.L877:
 1234        TYPE = UMASK;  LOOKUP(0)
				movl	$512, 84(%rsp)
		
				movq	%rbp, %r10
				movl	$0, %edi
				call	LOOKUP.32
		.LVL706:
 1235        ->MACCALL %IF TYPE&OPMASK = MACRO
				movl	84(%rsp), %edx
				movl	%edx, %eax
				andl	$61440, %eax
				cmpl	$40960, %eax
				je	.L748
		.LDL193:
		.LDL204:
 1236        ->MINST %IF TYPE&OPMASK # 0
				testl	%eax, %eax
				je	.L875
		.LDL194:
		.LDL205:
 1237        FAULT('U') %AND ->LEND %IF TYPE&UMASK # 0
				testb	$2, %dh
				jne	.L877
		.LDL206:
				leaq	16(%rsp), %r10
				movl	$85, %edi
				call	FAULT.45
		.LVL736:
				jmp	.L718
		.L880:
 1238        PEND = -1
				movl	$-1, 16(%rsp)
		
		.L723:
 1239     %FINISH
				movl	$-1, %eax
		.L747:
 1240     MODE = -1
 1241 DATA:
 1242     %CYCLE
 1243        GET EXP;  ASSEMBLE
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL741:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL742:
 1244        FAULT('I') %IF TYPE&REGXMASK # 0
				movq	%rbp, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL737:
				jmp	.L754
		.LVL738:
		.L763:
				testb	$-112, 84(%rsp)
				jne	.L880
		.L754:
 1245        I = 1
		.LVL743:
				cmpl	$1000, %ebx
				movl	$1, %eax
				cmovge	%eax, %ebx
		.L756:
		.LVL745:
				movl	$1, %ebx
				jmp	.L764
		.LVL749:
		.L881:
 1246        %IF S('$') %START
				movq	%rbp, %r10
				movl	$36, %edi
				call	S.33
		.LVL744:
				testl	%eax, %eax
				jne	.L825
 1247           I = VAL %IF VAL < 1000
				movl	80(%rsp), %ebx
 1248           QLIM = QSTART
				movl	QSTART.124(%rip), %eax
				movl	%eax, QLIM.123(%rip)
 1249           GET EXP;  ASSEMBLE
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL746:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL747:
 1250        %FINISH
 1251        %WHILE I > 0 %CYCLE
		.LDL207:
				testl	%ebx, %ebx
				jg	.L764
				jmp	.L763
		.LVL748:
		.L825:
				subl	$1, %ebx
		.LVL754:
				je	.L763
		.LVL755:
		.L764:
 1252           %IF MODE # -1 %START
		.LDL208:
				movl	36(%rsp), %r13d
				cmpl	$-1, %r13d
				je	.L881
 1253              FAULT('T') %IF VAL&16_FF00 # 0
				movq	%rbp, %r10
				movl	$84, %edi
				call	FAULT.45
		.LVL751:
				jmp	.L761
		.L883:
				movl	80(%rsp), %r12d
				testl	$65280, %r12d
				jne	.L882
		.L761:
 1254              %IF MODE = -2 %START
		.LDL209:
				cmpl	$-2, %r13d
				jne	.L883
 1255                 J = VAL<<8;  MODE = -3
				movl	%r12d, %r15d
		.LVL756:
				sall	$8, %r15d
		.LVL757:
				movl	$-3, 36(%rsp)
		
 1256              %finish %ELSE %START
				jmp	.L760
		.L879:
 1257                 VAL = VAL+J;  MODE = -2
				addl	%r15d, %r12d
				movl	%r12d, 80(%rsp)
				movl	$-2, 36(%rsp)
		
 1258                 PLANT VAL;  VAL = VAL&255
				movq	%rbp, %r10
				call	PLANTVAL.1
		.LVL752:
				andl	$255, 80(%rsp)
		
		.L760:
 1259              %FINISH
 1260           %finish %ELSE %START
 1261              PLANT VAL
				movq	%rbp, %r10
				call	PLANTVAL.1
		.LVL750:
				jmp	.L760
		.L882:
 1262           %FINISH
 1263           I = I-1
		.LVL753:
 1264        %REPEAT
 1265        %EXIT %UNLESS S(',') %OR SYM&128 # 0
				movq	%rbp, %r10
				movl	$44, %edi
				call	S.33
		.LVL739:
				testl	%eax, %eax
				jne	.L878
				testb	$-128, 20(%rsp)
				je	.L879
		.L765:
		.LDL210:
 1266        %IF SYM = NL %START
				cmpl	$10, 20(%rsp)
				jne	.L765
 1267           PRINT LINE %IF PRINTPOS # 0;  READ LINE
				cmpl	$0, PRINTPOS.104(%rip)
				jne	.L884
		.L767:
				movq	%rbp, %r10
				call	READLINE.38
		.LVL759:
				movq	%rbp, %r10
				call	PRINTLINE.47
		.LVL760:
				jmp	.L767
		.LVL761:
		.L862:
 1268           QSTART = QBASE
				movl	QBASE.125(%rip), %eax
				movl	%eax, QSTART.124(%rip)
				jmp	.L765
		.L884:
 1269        %FINISH
 1270        QLIM = QSTART
				movl	QSTART.124(%rip), %eax
				movl	%eax, QLIM.123(%rip)
 1271     %REPEAT
		.LVL740:
		.L768:
 1272     VAL=J %AND PLANT VAL %IF MODE = -3
				cmpl	$-3, 36(%rsp)
				jne	.L706
				movl	%r15d, 80(%rsp)
				movq	%rbp, %r10
				call	PLANTVAL.1
		.LVL758:
				jmp	.L706
		.L878:
		.L757:
 1273     ->SEND
 1274 
 1275 LABDEF:
 1276     CREG = -1;  ATYPE = -1
				movl	$-1, 72(%rsp)
		
				movl	$-1, 76(%rsp)
		
 1277     GET SYM
				movq	%rbp, %r10
				call	GETSYM.7
		.LVL687:
 1278     FAULT('C') %AND NP=STORELIM %IF NP # STORELIM
				movl	STORELIM.139(%rip), %ebx
				cmpl	%ebx, NP.138(%rip)
				je	.L727
				movq	%rbp, %r10
				movl	$67, %edi
				call	FAULT.45
		.LVL688:
				movl	%ebx, NP.138(%rip)
		.L727:
 1279     TYPE = LOCTYPE;  VAL = LOC
				movl	88(%rsp), %eax
				movl	%eax, 84(%rsp)
				movl	92(%rsp), %eax
				movl	%eax, 80(%rsp)
 1280     LOOKUP(7)
				movq	%rbp, %r10
				movl	$7, %edi
				call	LOOKUP.32
		.LVL689:
 1281     ->NEXT
				jmp	.L682
		.L725:
 1282 
 1283 ASSIGN:
 1284     PEND = 1
				movl	$1, 16(%rsp)
		
 1285     GET EXP
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL690:
 1286     ->ERR %IF %NOT S('=')
				movq	%rbp, %r10
				movl	$61, %edi
				call	S.33
		.LVL691:
				testl	%eax, %eax
				je	.L732
		.LDL174:
 1287     QUEUE(-25);                       !'STORE'
				movl	$-25, %edi
				call	QUEUE.9
		.LVL692:
 1288     %IF INTEGER(QBASE) = REG %START
				movl	QBASE.125(%rip), %edi
				call	INTEGER.39
		.LVL693:
				cmpl	$128, %eax
				je	.L862
		.L770:
 1289        DREG = INTEGER(QBASE+1)
				movl	QBASE.125(%rip), %eax
				leal	1(%rax), %edi
				call	INTEGER.39
		.LVL762:
				movl	%eax, 44(%rsp)
 1290        DUSE = 0
				movl	$0, 40(%rsp)
		
				jmp	.L770
		.L863:
 1291     %FINISH
 1292     QSTART = QLIM;  MODE = 2
				movl	QLIM.123(%rip), %eax
				movl	%eax, QSTART.124(%rip)
				movl	$2, 36(%rsp)
		
 1293     GET EXP
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL694:
 1294     %IF FLAG # 0 %START
				movl	68(%rsp), %eax
				testl	%eax, %eax
				je	.L778
 1295        %IF DREG<0 %AND FLAG-QSTART=QSTART-QBASE-1 %C
				cmpl	$0, 44(%rsp)
				jns	.L772
				movl	QSTART.124(%rip), %edx
				movl	QBASE.125(%rip), %edi
				subl	%edx, %eax
				subl	%edi, %edx
				subl	$1, %edx
				cmpl	%edx, %eax
				je	.L863
		.L772:
				call	INTEGER.39
		.LVL763:
				testb	$1, %ah
				jne	.L772
 1296           %AND INTEGER(QBASE)&BMASK=0 %START
 1297        I = QBASE;  J = QSTART
		.LVL764:
				movl	QSTART.124(%rip), %eax
		.LVL765:
				movl	%eax, %r15d
				movl	QBASE.125(%rip), %r12d
				subl	%eax, %r12d
		.LVL766:
		.L773:
				leal	(%r12,%r15), %edi
		.LVL767:
 1298        I = I+1 %AND J=J+1 %WHILE INTEGER(I) = INTEGER(J)
				call	INTEGER.39
		.LVL768:
				movl	%eax, %ebx
				movl	%r15d, %edi
				call	INTEGER.39
		.LVL769:
				cmpl	%eax, %ebx
				jne	.L885
		.LVL770:
				addl	$1, %r15d
		.LVL771:
				jmp	.L773
		.LVL772:
		.L885:
		.LDL211:
 1299        %IF J = FLAG %START
				cmpl	68(%rsp), %r15d
				je	.L886
		.LDL212:
 1300           %IF INTEGER(QLIM-1) = -2 %START; !MINUS
				movl	QLIM.123(%rip), %eax
				leal	-1(%rax), %edi
				call	INTEGER.39
		.LVL773:
				cmpl	$-2, %eax
				je	.L777
		.LDL213:
 1301              QSTART = J-2
				leal	-2(%r15), %edi
				movl	%edi, QSTART.124(%rip)
 1302 !!             INTEGER(QSTART) = 0;  INTEGER(QSTART+1) = 0
 1303              set INTEGER(QSTART, 0);  set INTEGER(QSTART+1, 0)
				movl	$0, %esi
				call	SETINTEGER.8
		.LVL774:
				leal	-1(%r15), %edi
				movl	$0, %esi
				call	SETINTEGER.8
		.LVL775:
 1304           %ELSE
				jmp	.L778
		.LVL776:
		.L864:
 1305              QSTART = J;  QLIM = QLIM-1
				movl	%r15d, QSTART.124(%rip)
				subl	$1, QLIM.123(%rip)
				jmp	.L778
		.L777:
 1306           %FINISH
 1307        %finish %ELSE FLAG = 0
				movl	$0, 68(%rsp)
		
				jmp	.L778
		.L886:
 1308        %finish %ELSE FLAG = 0
				movl	$0, 68(%rsp)
		
		.L771:
		.L778:
 1309     %FINISH
 1310     QUEUE(-24);                       !'LOAD'
				movl	$-24, %edi
				call	QUEUE.9
		.LVL695:
		.L736:
 1311 
 1312 CONDQ:
 1313     %IF TAGIF %START
				movq	%rbp, %r10
				call	TAGIF.12
		.LVL696:
				testl	%eax, %eax
				je	.L864
		.L779:
 1314        MODE = MODE+4;  DREG = DREG-16; !SCARIFY
				addl	$4, 36(%rsp)
				subl	$16, 44(%rsp)
 1315        CONDIT(0)
				movq	%rbp, %r10
				movl	$0, %edi
				call	CONDIT.11
		.LVL777:
 1316        MODE = MODE-4;  DREG = DREG+16; !RESTORE
				subl	$4, 36(%rsp)
				addl	$16, 44(%rsp)
 1317        QLIM = QSTART;  QSTART = TRANSF
				movl	QSTART.124(%rip), %eax
				movl	%eax, QLIM.123(%rip)
				movl	TRANSF.101(%rip), %eax
				movl	%eax, QSTART.124(%rip)
				jmp	.L779
		.L780:
 1318     %FINISH
 1319     ASSEMBLE
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL697:
 1320     ->SEND
		.L706:
		.LDL175:
 1321 
 1322 JUMP:
 1323     FLAG = TAG2-P;                    !POSITIVE IF SHORT
				subl	$17206, %edx
				movl	%edx, 68(%rsp)
 1324     GET EXP
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL704:
 1325     QUEUE(-26);                       !'JUMP'
				movl	$-26, %edi
				call	QUEUE.9
		.LVL705:
 1326     ->CONDQ
				jmp	.L736
		.L729:
 1327 
 1328 MINST:
 1329     MODE = -1
				movl	$-1, 36(%rsp)
		
 1330     GET INST
				movq	%rbp, %r10
				call	GETINST.14
		.LVL707:
 1331     QUEUE(-23);                       !'PLANT'
				movl	$-23, %edi
				call	QUEUE.9
		.LVL708:
 1332     ->CONDQ
				jmp	.L736
		.L737:
 1333 
 1334 MACCALL:
 1335     QUEUE(0);                         !(DEFPOS)
				movl	$0, %edi
				call	QUEUE.9
		.LVL730:
 1336     QUEUE(0);                         !SPARE
				movl	$0, %edi
				call	QUEUE.9
		.LVL731:
 1337     QUEUE(0);                         !(CALLPOS)
				movl	$0, %edi
				call	QUEUE.9
		.LVL732:
 1338     QUEUE(STARTPOS)
				movl	STARTPOS.132(%rip), %edi
				call	QUEUE.9
		.LVL733:
 1339     QUEUE(MP)
				movl	MP.131(%rip), %edi
				call	QUEUE.9
		.LVL734:
 1340     J = VAL;  QQ = 0
				movl	80(%rsp), %r15d
		.LVL735:
 1341     %CYCLE
 1342        %EXIT %IF CHAR(J) = NL;        !END OF MAC DEF
		.LDL214:
				movl	%r15d, %edi
				call	CHAR.6
		.LVL788:
				cmpl	$10, %eax
				je	.L780
		.LDL215:
 1343        I = GETPOS-1;                  !SAVE CALLPOS
				movl	GETPOS.100(%rip), %eax
				leal	-1(%rax), %r12d
		.LVL789:
 1344        GETPOS = J;  GET SYM
				leaq	16(%rsp), %rbx
				jmp	.L751
		.L875:
				movl	%r15d, GETPOS.100(%rip)
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL790:
 1345 !!       %MONITOR 24 %IF %NOT TAG
 1346        TYPE = 0;  VAL = 0
				movl	$0, 84(%rsp)
		
				movl	$0, 80(%rsp)
		
 1347        SCAN ARG
				movq	%rbx, %r10
				call	SCANARG.31
		.LVL791:
 1348        GET SYM %IF SYM = ','
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL783:
				jmp	.L781
		.L785:
				cmpl	$44, 20(%rsp)
				je	.L889
		.L781:
 1349        J = GETPOS-1;                  !SAVE DEFPOS
				movl	GETPOS.100(%rip), %eax
				leal	-1(%rax), %r15d
		.LVL792:
 1350        GETPOS = I;  GET SYM;          !RESTORE CALLPOS
				movl	%r12d, GETPOS.100(%rip)
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL793:
 1351        SCAN ARG
				movq	%rbx, %r10
				call	SCANARG.31
		.LVL794:
 1352        GET SYM %IF SYM = ','
				cmpl	$44, 20(%rsp)
				jne	.L785
				movq	%rbx, %r10
				call	GETSYM.7
		.LVL795:
				jmp	.L785
		.LVL796:
		.L887:
 1353        QUEUE(TAG1);  QUEUE(TAG2)
				movl	32(%rsp), %edi
				call	QUEUE.9
		.LVL784:
				movl	28(%rsp), %edi
				call	QUEUE.9
		.LVL785:
 1354        QUEUE(TYPE);  QUEUE(VAL)
				movl	84(%rsp), %edi
				call	QUEUE.9
		.LVL786:
				movl	80(%rsp), %edi
				call	QUEUE.9
		.LVL787:
 1355     %REPEAT
		.L751:
 1356     QQ = '?'
				movl	$63, QQ.106(%rip)
		
 1357     GET SYM %IF SYM = ' '
				cmpl	$32, 20(%rsp)
				je	.L887
		.L783:
				leaq	16(%rsp), %r10
				call	GETSYM.7
		.LVL797:
				jmp	.L783
		.L888:
 1358     %IF TAGIF %START
				leaq	16(%rsp), %r10
				call	TAGIF.12
		.LVL778:
				testl	%eax, %eax
				je	.L888
		.L786:
 1359        CONDIT(-18)
				leaq	16(%rsp), %r10
				movl	$-18, %edi
				call	CONDIT.11
		.LVL798:
 1360        QLIM = QSTART
				movl	QSTART.124(%rip), %eax
				movl	%eax, QLIM.123(%rip)
 1361 !!       INTEGER(QBASE+4) = MP+8_700000
 1362        set INTEGER(QBASE+4, MP+8_700000)
				movl	MP.131(%rip), %eax
				leal	229376(%rax), %esi
				movl	QBASE.125(%rip), %eax
				leal	4(%rax), %edi
				call	SETINTEGER.8
		.LVL799:
				jmp	.L786
		.LVL800:
		.L890:
 1363     %FINISH
 1364     QUEUE(0)
				movl	$0, %edi
				call	QUEUE.9
		.LVL779:
 1365     STARTPOS = QLIM<<1
				movl	QLIM.123(%rip), %eax
				addl	%eax, %eax
				movl	%eax, STARTPOS.132(%rip)
 1366     MP = QBASE
				movl	QBASE.125(%rip), %ebx
				movl	%ebx, MP.131(%rip)
 1367 !!    INTEGER(MP) = J+1;                !START OF BODY
 1368     set INTEGER(MP, J+1);                !START OF BODY
				leal	1(%r15), %esi
				movl	%ebx, %edi
				call	SETINTEGER.8
		.LVL780:
 1369 !!    INTEGER(MP+2) = GETPOS-1
 1370     set INTEGER(MP+2, GETPOS-1)
				movl	GETPOS.100(%rip), %eax
				leal	-1(%rax), %esi
				leal	2(%rbx), %edi
				call	SETINTEGER.8
		.LVL781:
 1371     ->LEND
				jmp	.L718
		.LVL782:
		.L889:
 1372 
 1373 !CODING OF JUMPS: 1000 (SINGLE INST), 2000 (MAIN IF)
 1374 !                 4000 (ELSE), 6000 (IF AFTER ELSE)
 1375 
 1376 IFC:
 1377     CONDIT(-15)
				movq	%rbp, %r10
				movl	$-15, %edi
				call	CONDIT.11
		.LVL709:
 1378     ->SEND
				jmp	.L706
		.L873:
 1379 
 1380 ELSE:
 1381     ->CERR %IF INTEGER(NP)&16_2000 = 0
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL710:
				testb	$32, %ah
				je	.L701
		.LDL197:
 1382     QUEUE(0);  QUEUE(0)
				movl	$0, %edi
				call	QUEUE.9
		.LVL711:
				movl	$0, %edi
				call	QUEUE.9
		.LVL712:
 1383     QUEUE(-16);  ASSEMBLE
				movl	$-16, %edi
				call	QUEUE.9
		.LVL713:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL714:
 1384     ATYPE = -1; CREG = -1
				movl	$-1, 76(%rsp)
		
				movl	$-1, 72(%rsp)
		
 1385     %IF TAGIF %START
				movq	%rbp, %r10
				call	TAGIF.12
		.LVL715:
				testl	%eax, %eax
				jne	.L706
 1386        CONDIT(-17)
				movq	%rbp, %r10
				movl	$-17, %edi
				call	CONDIT.11
		.LVL716:
				jmp	.L706
		.L872:
		.L738:
 1387     %FINISH
 1388     ->SEND
 1389 
 1390 FINISH:
 1391     ->CERR %IF INTEGER(NP)&16_6000 = 0
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL722:
				testb	$96, %ah
				je	.L701
		.LDL201:
 1392     I = LOC
				movl	92(%rsp), %ebx
				jmp	.L787
		.L856:
 1393     %WHILE INTEGER(NP)&16_4000 # 0 %CYCLE
		.LDL216:
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL803:
				testb	$64, %ah
				je	.L890
 1394        %IF INTEGER(NP)&16_2000 # 0 %START; !IF AFTER ELSE
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL804:
				testb	$32, %ah
				jne	.L789
		.LDL217:
 1395           SET LAB(I)
				movq	%rbp, %r10
				movl	%ebx, %edi
				call	SETLAB.10
		.LVL802:
 1396        %finish %ELSE %START
		.L787:
 1397           SET LAB(LOC)
				movq	%rbp, %r10
				movl	92(%rsp), %edi
				call	SETLAB.10
		.LVL805:
 1398           I = VAL+4
				movl	80(%rsp), %eax
				leal	4(%rax), %ebx
		.LVL806:
				jmp	.L787
		.LVL807:
		.L865:
 1399        %FINISH
 1400     %REPEAT
 1401     SET LAB(I)
				movq	%rbp, %r10
				movl	%ebx, %edi
				call	SETLAB.10
		.LVL801:
 1402     ->SEND
				jmp	.L706
		.L789:
 1403 
 1404 WHILE:
 1405     I = LOC;  ATYPE = -1;  CREG = -1
				movl	92(%rsp), %ebx
		.LVL723:
				movl	$-1, 76(%rsp)
		
				movl	$-1, 72(%rsp)
		
 1406     CONDIT(-13)
				movq	%rbp, %r10
				movl	$-13, %edi
				call	CONDIT.11
		.LVL724:
 1407     NEST(I);  NEST(1)
				movl	%ebx, %edi
				call	NEST.0
		.LVL725:
				movl	$1, %edi
				call	NEST.0
		.LVL726:
 1408     ->SEND
				jmp	.L706
		.LVL727:
		.L874:
 1409 
 1410 CYCLE:
 1411     NEST(LOC);  NEST(1)
				movl	92(%rsp), %edi
				call	NEST.0
		.LVL728:
				movl	$1, %edi
				call	NEST.0
		.LVL729:
 1412     ATYPE = -1;  CREG = -1
				movl	$-1, 76(%rsp)
		
				movl	$-1, 72(%rsp)
		
 1413     ->SEND
				jmp	.L706
		.L748:
 1414 
 1415 REPEAT:
 1416     ->CERR %IF INTEGER(NP) # 1
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL717:
				cmpl	$1, %eax
				jne	.L701
		.LDL199:
 1417     QUEUE(LOCTYPE);  QUEUE(INTEGER(NP+1))
				movl	88(%rsp), %edi
				call	QUEUE.9
		.LVL718:
				movl	NP.138(%rip), %eax
				leal	1(%rax), %edi
				call	INTEGER.39
		.LVL719:
				movl	%eax, %edi
				call	QUEUE.9
		.LVL720:
 1418     NP = NP+2
				addl	$2, NP.138(%rip)
 1419     QUEUE(-26);                       !'JUMP'
				movl	$-26, %edi
				call	QUEUE.9
		.LVL721:
 1420     FLAG = -1
				movl	$-1, 68(%rsp)
		
 1421     ->CONDQ
				jmp	.L736
		.L876:
 1422 
 1423 CERR:
 1424     FAULT('C')
				movq	%rbp, %r10
				movl	$67, %edi
				call	FAULT.45
		.LVL682:
 1425     ->LEND
				jmp	.L794
		.L859:
 1426 
 1427 SEND:
 1428     SET LAB(LOC) %IF INTEGER(NP)&16_1000 # 0
				movl	NP.138(%rip), %edi
				call	INTEGER.39
		.LVL698:
				testb	$16, %ah
				jne	.L865
		.L791:
				movq	%rbp, %r10
				movl	92(%rsp), %edi
				call	SETLAB.10
		.LVL808:
				jmp	.L791
		.L689:
		.LDL218:
 1429     ->LEND %IF SYM = NL
				cmpl	$10, 20(%rsp)
				je	.L794
		.LDL176:
 1430     ->NEXT %IF S(';')
				movq	%rbp, %r10
				movl	$59, %edi
				call	S.33
		.LVL699:
				testl	%eax, %eax
				jne	.L689
		.L682:
 1431 
 1432 ERR:FSYM = 'F';  FAULTPOS = GETPOS-1
				movl	$70, 96(%rsp)
		
				movl	GETPOS.100(%rip), %eax
				subl	$1, %eax
				movl	%eax, FAULTPOS.126(%rip)
				movl	$70, 96(%rsp)
		
				movl	GETPOS.100(%rip), %eax
				subl	$1, %eax
				movl	%eax, FAULTPOS.126(%rip)
 1433     PRINTPOS = STARTPOS
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PRINTPOS.104(%rip)
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PRINTPOS.104(%rip)
				movl	$0, %r14d
				jmp	.L792
		.LVL856:
		.L812:
 1434 
 1435 LEND:
 1436     ->READ %IF SKIP # 0 %AND LIST&4 = 0
				testl	%r14d, %r14d
				je	.L722
		.L694:
		.LVL653:
				testb	$4, LIST.118(%rip)
				je	.L681
		.L722:
				testl	%r14d, %r14d
				je	.L792
		.LVL809:
				testb	$4, LIST.118(%rip)
				je	.L681
		.L792:
		.LVL855:
 1437     ->READ %IF FSYM = ' ' %AND CHARS = 0 %AND %C
				cmpl	$32, 96(%rsp)
				jne	.L792
				cmpl	$0, CHARS.99(%rip)
				jne	.L792
				cmpl	$0, PRINTPOS.104(%rip)
				je	.L681
				cmpl	$0, MP.131(%rip)
				je	.L792
				testb	$2, LIST.118(%rip)
				je	.L681
				jmp	.L792
		.LVL654:
		.L690:
 1438      (PRINTPOS = 0 %OR (MP#0 %AND LIST&2=0))
 1439     PRINT LINE
				movq	%rbp, %r10
				call	PRINTLINE.47
		.LVL810:
 1440     ->READ
		.L681:
 1441 
 1442 ASSIF:
 1443     ASSCOND = ASSCOND<<1
				sall	12(%rsp)
		.LVL655:
 1444     ->LEND %IF SKIP # 0
				testl	%r14d, %r14d
				jne	.L694
		.LVL656:
		.L693:
		.LDL156:
 1445 A1: CONDIT(0)
				movq	%rbp, %r10
				movl	$0, %edi
				call	CONDIT.11
		.LVL657:
 1446     SKIP = ASSCOND %IF COND # 0
				movl	64(%rsp), %eax
				testl	%eax, %eax
				je	.L796
		.L797:
		.LVL658:
 1447     PRINT LINE %IF PRINTPOS # 0
				movl	12(%rsp), %eax
				movl	%eax, %r14d
				cmpl	$0, PRINTPOS.104(%rip)
				je	.L794
		.LVL659:
		.L821:
				movq	%rbp, %r10
				call	PRINTLINE.47
		.LVL660:
				jmp	.L794
		.LVL661:
		.L868:
				movl	PRINTPOS.104(%rip), %r14d
				testl	%r14d, %r14d
				je	.L722
				movl	%eax, %r14d
				jmp	.L821
		.LVL878:
		.L895:
				call	__stack_chk_fail@PLT
		.LVL879:
		.LFE230:
				.section	.rodata
				.align 8
		__PRETTY_FUNCTION__.50:
				.string	"_imp_OUTDEV"
		
		
				.comm	SEQ.51,4,4
				.comm	HOLD.52,4,4
				.align 16
		__PRETTY_FUNCTION__.53:
				.string	"_imp_SELECTINPUT"
		
		
		
				.comm	ZQUERY.66,4,4
				.section	.data.rel.local,"aw"
				.align 32
		sw1_ASS.80:
				.quad	.L603
		
				.quad	.L604
		
				.quad	.L605
		
				.quad	.L606
		
				.quad	.L595
		
				.quad	.L586
		
				.quad	.L584
		
				.quad	.L582
		
				.quad	.L571
		
				.quad	.L564
		
				.quad	.L563
		
				.quad	.L607
		
				.quad	.L562
		
				.quad	.L561
		
				.quad	.L560
		
				.quad	.L559
		
				.quad	.L557
		
				.quad	.L553
		
				.quad	.L552
		
				.quad	.L533
		
				.quad	.L608
		
				.quad	.L609
		
				.quad	.L530
		
				.quad	.L529
		
				.quad	.L527
		
				.quad	.L526
		
				.quad	.L525
		
				.quad	.L524
		
				.quad	.L516
		
				.quad	.L520
		
				.section	.rodata
				.align 16
		
		
		__PRETTY_FUNCTION__.85:
				.string	"_imp_SELECTOUTPUT"
		
		
		
				.comm	CHECK.91,4,4
				.comm	BREC.92,208,32
				.data
				.align 4
		PASS.93:
				.long	-1
				.comm	PSEUDOLIM.94,4,4
				.comm	PUTPOS.95,4,4
				.comm	BINCOUNT.96,4,4
				.align 4
		TEMPS.97:
				.long	12
				.comm	LINES.98,4,4
				.comm	CHARS.99,4,4
				.comm	GETPOS.100,4,4
				.comm	TRANSF.101,4,4
				.comm	PRINTPOS.104,4,4
				.align 4
		QQ.106:
				.long	63
				.align 4
		SAVE.117:
				.long	1
				.align 4
		LIST.118:
				.long	-1
				.comm	QLIM.123,4,4
				.comm	QSTART.124,4,4
				.comm	QBASE.125,4,4
				.comm	FAULTPOS.126,4,4
				.comm	LABMIN.129,4,4
				.comm	ALMAX.130,4,4
				.comm	MP.131,4,4
				.comm	STARTPOS.132,4,4
				.comm	STORE.133,130048,32
				.comm	DEFMIN.134,4,4
				.comm	DEFLIM.135,4,4
				.comm	BP.136,4,4
				.comm	LABLIM.137,4,4
				.comm	NP.138,4,4
				.comm	STORELIM.139,4,4
				.comm	MACLIM.140,4,4
				.comm	CODEPOS.141,4,4
		.Letext0:
				.section	.note.gnu.property,"a"
				.align 8
				.long	1f - 0f
				.long	4f - 1f
				.long	5
		0:
				.string	"GNU"
		1:
				.align 8
				.long	0xc0000002
				.long	3f - 2f
		2:
				.long	0x3
		3:
				.align 8
		4:
 1448     ->LEND
 1449 
 1450 ASSELSE:
 1451     %IF SKIP = 0 %START
				testl	%r14d, %r14d
				jne	.L857
		.LDL219:
 1452        ->CERR %IF ASSCOND&1 # 0
				movl	12(%rsp), %eax
				testb	$1, %al
				jne	.L701
		.LDL158:
 1453        SKIP = ASSCOND
		.LVL662:
 1454     %finish %ELSE %START
		.LDL159:
 1455        ->LEND %IF SKIP # ASSCOND
				movl	12(%rsp), %eax
				cmpl	%eax, %r14d
				jne	.L694
		.LDL220:
 1456        SKIP = 0
				movl	$0, %r14d
				jmp	.L722
		.LVL681:
		.L858:
		.LVL812:
				movl	%r12d, %r14d
				jmp	.L722
		.LVL815:
		.L702:
 1457        ->A1 %IF TAGIF
				leaq	16(%rsp), %r10
				call	TAGIF.12
		.LVL813:
				testl	%eax, %eax
				je	.L693
		.LDL221:
 1458     %FINISH
 1459     ASSCOND = ASSCOND+1
				leal	1(%rax), %eax
		.LVL663:
				movl	%eax, 12(%rsp)
				addl	$1, 12(%rsp)
		.LVL814:
 1460     ->LEND
				movl	%eax, %r14d
				jmp	.L794
		.LVL664:
		.L869:
 1461 
 1462 ASSFIN:
 1463     ->CERR %IF ASSCOND = 1
				cmpl	$1, 12(%rsp)
				je	.L701
		.LDL161:
 1464     ASSCOND = ASSCOND>>1
				movl	12(%rsp), %eax
				shrl	%eax
				movl	%eax, 12(%rsp)
		.LVL665:
 1465     SKIP = 0 %IF SKIP>>1 = ASSCOND
				movl	%r14d, %edx
				shrl	%edx
				cmpl	%edx, %eax
				jne	.L794
		.LVL666:
				movl	%r12d, %r14d
				jmp	.L722
		.LVL667:
		.L703:
 1466     ->LEND
 1467 
 1468 DEFINE:
 1469     FAULT('C') %IF NP # STORELIM
				movl	STORELIM.139(%rip), %eax
				cmpl	%eax, NP.138(%rip)
				je	.L805
				movq	%rbp, %r10
				movl	$67, %edi
				call	FAULT.45
		.LVL816:
				jmp	.L805
		.LVL817:
		.L800:
 1470     I = TAG1
 1471     %CYCLE
 1472        ->ERR %IF %NOT (TAG %AND S('='))
				movq	%rbp, %r10
				call	TAG.34
		.LVL824:
				testl	%eax, %eax
				jne	.L732
				movq	%rbp, %r10
				movl	$61, %edi
				call	S.33
		.LVL825:
				testl	%eax, %eax
				je	.L732
		.LDL225:
 1473        J = TAG1;  K = TAG2
				movl	32(%rsp), %r15d
		.LVL826:
				movl	28(%rsp), %r12d
		.LVL827:
 1474        %IF TAG %START
				movq	%rbp, %r10
				call	TAG.34
		.LVL828:
				testl	%eax, %eax
				je	.L800
		.LDL226:
 1475           TAGREF
				movq	%rbp, %r10
				call	TAGREF.13
		.LVL818:
 1476           %IF TYPE&OPMASK # 0 %START
				testl	$61440, 84(%rsp)
		
				jne	.L802
		.LDL222:
 1477              GET INST
				movq	%rbp, %r10
				call	GETINST.14
		.LVL830:
 1478           %finish %ELSE %START
				jmp	.L801
		.L803:
 1479              PEND = -1;  GET EXP
				movl	$-1, 16(%rsp)
		
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL819:
		.L801:
 1480           %FINISH
 1481        %finish %ELSE GET EXP
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL829:
				jmp	.L801
		.L802:
 1482        ASSEMBLE
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL820:
 1483        TAG1 = J;  TAG2 = K
				movl	%r15d, 32(%rsp)
				movl	%r12d, 28(%rsp)
 1484        %IF I=DEF %THEN LOOKUP(3) %ELSE LOOKUP(2)
				cmpl	$4605, %ebx
				je	.L803
		.LDL223:
				movq	%rbp, %r10
				movl	$2, %edi
				call	LOOKUP.32
		.LVL821:
		.L804:
				movq	%rbp, %r10
				movl	$3, %edi
				call	LOOKUP.32
		.LVL831:
				jmp	.L804
		.LVL832:
		.L807:
 1485        %EXIT %UNLESS S(',')
				movq	%rbp, %r10
				movl	$44, %edi
				call	S.33
		.LVL822:
				testl	%eax, %eax
				je	.L706
		.LDL224:
 1486        QLIM = QSTART
				movl	QSTART.124(%rip), %eax
				movl	%eax, QLIM.123(%rip)
 1487     %REPEAT
		.LVL823:
		.L805:
 1488     ->SEND
 1489 
 1490 NEWPAGE:
 1491     DO NEWLINE %WHILE LINES # 0
				cmpl	$0, LINES.98(%rip)
				je	.L794
		.L806:
				call	DONEWLINE.15
		.LVL651:
				cmpl	$0, LINES.98(%rip)
				jne	.L806
		.L687:
		.LVL652:
		.L794:
		.LDL152:
		.LDL153:
		.LDL154:
				movl	LINES.98(%rip), %eax
				testl	%eax, %eax
				jne	.L806
		.LVL684:
				movl	%eax, %r14d
				jmp	.L722
		.LVL685:
		.L860:
 1492     ->LEND
 1493 
 1494 LISTC:
 1495     GET EXP;  ASSEMBLE
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL668:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL669:
 1496     LIST = VAL
				movl	80(%rsp), %eax
				movl	%eax, LIST.118(%rip)
 1497     ->SEND
				jmp	.L706
		.L870:
 1498 
 1499 TEMP:
 1500     I = 0
		.LVL670:
				movl	%r14d, %ebx
 1501     %IF SYM # NL %START
				cmpl	$10, 20(%rsp)
				jne	.L708
		.LVL671:
		.L707:
		.LDL164:
 1502        %CYCLE
 1503           GET EXP
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL836:
 1504           FAULT('I') %IF TYPE # REG
				cmpl	$128, 84(%rsp)
		
				je	.L807
				movq	%rbp, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL837:
				jmp	.L807
		.LVL838:
		.L709:
 1505           I = I!1<<VAL
				movl	80(%rsp), %ecx
				movl	$1, %eax
				sall	%cl, %eax
				orl	%eax, %ebx
		.LVL833:
 1506           %EXIT %UNLESS S(',')
				movq	%rbp, %r10
				movl	$44, %edi
				call	S.33
		.LVL834:
				testl	%eax, %eax
				je	.L707
		.LVL835:
		.L708:
		.LDL227:
 1507        %REPEAT
 1508     %FINISH
 1509     TEMPS = I
				movl	%ebx, TEMPS.97(%rip)
 1510     SET ACC
				movq	%rbp, %r10
				call	SETACC.40
		.LVL672:
 1511     ->SEND
				jmp	.L706
		.LVL673:
		.L871:
 1512 
 1513 LOCC:
 1514     I = TAG1
 1515     GET EXP;  ASSEMBLE
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL839:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL840:
 1516     %IF TYPE&16_FF80 = 0 %START
				testl	$65408, 84(%rsp)
		
				jne	.L891
		.LDL228:
 1517        %IF I = 13556 %START;          !LOC
				cmpl	$13556, %ebx
				jne	.L809
 1518           OUTPUT RECORD %IF BINCOUNT >= 203
				cmpl	$202, BINCOUNT.96(%rip)
		
				jg	.L892
		.L810:
				call	OUTPUTRECORD.43
		.LVL844:
				jmp	.L810
		.L893:
 1519           PUT(3) %IF (LOCTYPE!!TYPE)&RELMASK # 0
				movl	88(%rsp), %eax
				xorl	84(%rsp), %eax
				testb	$32, %al
				jne	.L893
		.L811:
				movl	$3, %edi
				call	PUT.42
		.LVL845:
				jmp	.L811
		.LVL846:
		.L861:
 1520           PUT(5);  PUT WORD(VAL)
				movl	$5, %edi
				call	PUT.42
		.LVL841:
				movl	80(%rsp), %edi
				call	PUTWORD.29
		.LVL842:
		.L809:
 1521        %FINISH
 1522        LOCTYPE = TYPE&63+MEMMASK;  LOC = VAL
				movl	84(%rsp), %eax
				andl	$63, %eax
				addl	$64, %eax
				movl	%eax, 88(%rsp)
				movl	80(%rsp), %eax
				movl	%eax, 92(%rsp)
 1523     %finish %ELSE FAULT('I')
				jmp	.L706
		.L891:
				movq	%rbp, %r10
				movl	$73, %edi
				call	FAULT.45
		.LVL843:
				jmp	.L706
		.L892:
 1524     ->SEND
 1525 
 1526 SAVC:
 1527     GET EXP;  ASSEMBLE
				movq	%rbp, %r10
				call	GETEXP.16
		.LVL702:
				movq	%rbp, %r10
				call	ASSEMBLE.18
		.LVL703:
 1528     SAVE = VAL
				movl	80(%rsp), %eax
				movl	%eax, SAVE.117(%rip)
 1529     ->SEND
				jmp	.L706
		.L735:
 1530 
 1531 MACDEF:
 1532     ->CERR %IF MP # 0
				cmpl	$0, MP.131(%rip)
				je	.L861
		.L701:
		.LDL229:
 1533     ->ERR %IF %NOT TAG
				leaq	16(%rsp), %r10
				call	TAG.34
		.LVL847:
				testl	%eax, %eax
				je	.L732
		.LDL230:
 1534     J = TAG1;  K = TAG2
				movl	32(%rsp), %r15d
		.LVL848:
				movl	28(%rsp), %r13d
		.LVL849:
 1535     I = GETPOS-1
				movl	GETPOS.100(%rip), %ebx
		.LVL850:
				subl	$1, %ebx
		.LVL857:
				movl	%ebx, 80(%rsp)
 1536     %IF SYM # NL %START
				cmpl	$10, 20(%rsp)
				je	.L812
 1537        %CYCLE
 1538           ->ERR %IF %NOT TAG
				leaq	16(%rsp), %r12
		.L813:
		.LDL231:
				movq	%r12, %r10
				call	TAG.34
		.LVL851:
				testl	%eax, %eax
				je	.L732
		.LDL232:
 1539           SCAN ARG
				movq	%r12, %r10
				call	SCANARG.31
		.LVL852:
 1540           %EXIT %IF %NOT S(',')
				movq	%r12, %r10
				movl	$44, %edi
				call	S.33
		.LVL853:
				testl	%eax, %eax
				jne	.L813
		.L814:
		.LDL233:
 1541        %REPEAT
 1542     %FINISH
 1543     ->ERR %IF SYM # NL
				cmpl	$10, 20(%rsp)
				je	.L812
		.LVL854:
		.L732:
		.LDL234:
 1544     TAG1 = J;  TAG2 = K
				movl	%r15d, 32(%rsp)
				movl	%r13d, 28(%rsp)
 1545     TYPE = MACRO;  VAL = I
				movl	$40960, 84(%rsp)
		
 1546     LOOKUP(3)
				leaq	16(%rsp), %r10
				movl	$3, %edi
				call	LOOKUP.32
		.LVL858:
 1547     %CYCLE
 1548        PRINT LINE
				leaq	16(%rsp), %rbx
		.LVL859:
				jmp	.L815
		.L816:
				movq	%rbx, %r10
				call	PRINTLINE.47
		.LVL861:
 1549        %EXIT %IF S('$') %AND TAG %AND TAG1 = END
				movq	%rbx, %r10
				movl	$36, %edi
				call	S.33
		.LVL862:
				testl	%eax, %eax
				jne	.L816
				movq	%rbx, %r10
				call	TAG.34
		.LVL863:
				testl	%eax, %eax
				jne	.L816
				cmpl	$6009, 32(%rsp)
		
				jne	.L816
		.LDL235:
 1550        STARTPOS = PUTPOS
				movl	PUTPOS.95(%rip), %eax
				movl	%eax, STARTPOS.132(%rip)
 1551        STARTPOS = PSEUDOLIM+1 %IF PSEUDOLIM # 0
				movl	PSEUDOLIM.94(%rip), %eax
				testl	%eax, %eax
				je	.L817
				addl	$1, %eax
				movl	%eax, STARTPOS.132(%rip)
		.L817:
 1552        READ LINE
				movq	%rbx, %r10
				call	READLINE.38
		.LVL860:
 1553     %REPEAT
		.L815:
 1554     PUTPOS = STARTPOS;  PUT CHAR(0)
				movl	STARTPOS.132(%rip), %eax
				movl	%eax, PUTPOS.95(%rip)
				movl	$0, %edi
				call	PUTCHAR.37
		.LVL864:
 1555     STARTPOS = PUTPOS
				movl	PUTPOS.95(%rip), %eax
				movl	%eax, STARTPOS.132(%rip)
 1556     MACLIM = STARTPOS
				movl	%eax, MACLIM.140(%rip)
 1557     ->LEND
				jmp	.L718
		.LVL865:
		.L819:
		.LDL236:
 1558 
 1559 %ROUTINE BNEST
				pushq	%rbp
				pushq	%rbx
 1560 !!    BP = BP+4;  %MONITOR 23 %IF BP-NP >= 0
 1561     BP = BP+4;  !{}%signal 2,3 %IF BP-NP >= 0
				movl	BP.136(%rip), %ebx
				leal	4(%rbx), %ebp
				movl	%ebp, BP.136(%rip)
 1562 !!    INTEGER(BP-3) = SAVE;  INTEGER(BP-2) = TEMPS
 1563     set INTEGER(BP-3, SAVE);  set INTEGER(BP-2, TEMPS)
				leal	1(%rbx), %edi
				movl	SAVE.117(%rip), %esi
				call	SETINTEGER.8
		.LVL92:
				leal	2(%rbx), %edi
				movl	TEMPS.97(%rip), %esi
				call	SETINTEGER.8
		.LVL93:
 1564 !!    INTEGER(BP-1) = MACLIM;  INTEGER(BP) = DEFMIN
 1565     set INTEGER(BP-1, MACLIM);  set INTEGER(BP, DEFMIN)
				leal	3(%rbx), %edi
				movl	MACLIM.140(%rip), %esi
				call	SETINTEGER.8
		.LVL94:
				movl	DEFMIN.134(%rip), %esi
				movl	%ebp, %edi
				call	SETINTEGER.8
		.LVL95:
 1566 %END
 1567 
 1568 BEGIN:
				popq	%rbx
				popq	%rbp
				ret
		.LFE279:
		DONEWLINE.15:
		.LFB241:
 1569     BNEST
				call	BNEST.41
		.LVL683:
 1570     ->NEWPAGE %IF SYM # NL
				cmpl	$10, 20(%rsp)
				je	.L718
 1571     ->LEND
 1572 
 1573 BEND:
 1574     FAULT('C') %IF NP # STORELIM %OR MP # 0
				movl	STORELIM.139(%rip), %ebx
				cmpl	%ebx, NP.138(%rip)
				jne	.L720
				cmpl	$0, MP.131(%rip)
				je	.L818
		.L720:
				leaq	16(%rsp), %r10
				movl	$67, %edi
				call	FAULT.45
		.LVL674:
		.L818:
 1575     MP = 0;  NP = STORELIM
				movl	$0, MP.131(%rip)
		
				movl	%ebx, NP.138(%rip)
 1576     %IF BP # LABLIM %START
				movl	BP.136(%rip), %eax
				cmpl	LABLIM.137(%rip), %eax
				je	.L819
 1577        SAVE = INTEGER(BP-3);  TEMPS = INTEGER(BP-2)
				leal	-3(%rax), %edi
				call	INTEGER.39
		.LVL675:
				movl	%eax, SAVE.117(%rip)
				movl	BP.136(%rip), %eax
				leal	-2(%rax), %edi
				call	INTEGER.39
		.LVL676:
				movl	%eax, TEMPS.97(%rip)
 1578        MACLIM = INTEGER(BP-1);  STARTPOS = MACLIM
				movl	BP.136(%rip), %eax
				leal	-1(%rax), %edi
				call	INTEGER.39
		.LVL677:
				movl	%eax, MACLIM.140(%rip)
				movl	%eax, STARTPOS.132(%rip)
 1579        DEFMIN = INTEGER(BP)
				movl	BP.136(%rip), %edi
				call	INTEGER.39
		.LVL678:
				movl	%eax, DEFMIN.134(%rip)
 1580        SET ACC
				movq	%rbp, %r10
				call	SETACC.40
		.LVL679:
 1581        BP = BP-4
				movl	BP.136(%rip), %eax
				subl	$4, %eax
				movl	%eax, BP.136(%rip)
 1582        ->LEND %IF BP # LABLIM
				cmpl	LABLIM.137(%rip), %eax
				je	.L819
		.L718:
		.LVL680:
 1583     %FINISH
 1584     CLOSE INPUT;  SELECT INPUT(MAIN)
		.LBB201:
		.LBI201:
 1585     BNEST
				call	BNEST.41
		.LVL868:
 1586     LIST = 5
				movl	$5, LIST.118(%rip)
		
 1587     PASS = PASS+1
				movl	PASS.93(%rip), %eax
				addl	$1, %eax
				movl	%eax, PASS.93(%rip)
 1588     ->DO PASS %IF PASS # 2
				cmpl	$2, %eax
				jne	.L679
		.LDL237:
 1589 
 1590     OUTPUT RECORD %IF BINCOUNT = 208
				cmpl	$208, BINCOUNT.96(%rip)
		
				je	.L894
		.L820:
				call	OUTPUTRECORD.43
		.LVL876:
				jmp	.L820
		.LVL877:
		.L796:
 1591     PUT(1)
				movl	$1, %edi
				call	PUT.42
		.LVL869:
 1592     OUTPUT RECORD
				call	OUTPUTRECORD.43
		.LVL870:
 1593     FAULT('$')
				leaq	16(%rsp), %rbx
				movq	%rbx, %r10
				movl	$36, %edi
				call	FAULT.45
		.LVL871:
 1594     PRINT LOC;  PRINT LINE
				movq	%rbx, %r10
				call	PRINTLOC.46
		.LVL872:
				movq	%rbx, %r10
				call	PRINTLINE.47
		.LVL873:
 1595 
 1596 %ENDOFPROGRAM

 1517 Statements compiled
				movq	1400(%rsp), %rax
		
				subq	%fs:40, %rax
		
				jne	.L895
				movl	$0, %eax
				addq	$1416, %rsp
				popq	%rbx
				popq	%rbp
				popq	%r12
				popq	%r13
				popq	%r14
				popq	%r15
		.LVL874:
				ret
		.LVL875:
		.L894:
