.NLIST	TTM
	.NLIST	BEX
	.TITLE	SOURCE 8080 MACRO ASSEMBLER
	.MCALL	.REGDEF,.PRINT,.CSIGEN,.WRITW,.READW,..V2..
	.MCALL	.EXIT,.CLOSE,.QSET,.INTEN,.READ,.WRITE
	.MCALL	.PROTECT,.SETTOP,.WAIT,.DATE

	..V2..
	.REGDEF
	.GLOBL	START

JSW	=	44
RNUM	=	512.		;LENGTH OF SOURCE INPUT BUFFER
LNUM	=	512.		;LENGTH OF LIST OUTPUT BUFFER
PNUM	=	512.		;LENGTH OF HEX OUTPUT BUFFER
ERRWRD	=	52
CR	=	13.
LF	=	10.
MCEND	=	26.		;MACRO TERMINATION IN MEMORY CHARACTER

START:	MOV	SP,STCKST
	JSR	PC,PDATE
	.QSET	#Q1,#5		;QUEUE SPACE
	.PRINT	#TTLE
RPEAT:	MOV	STCKST,SP
	.CSIGEN	#DEVS,#DEFLT,#0		;GET FILES AND SWITCHES
	MOV	R0,FREE			;FREE SPACE FOR ASSEMBLER
	MOV	(SP)+,R0
	BEQ	EDSW
SWLOP:	MOV	(SP)+,R1		;IDENTIFY SWITCHES
	BPL	1$
	MOV	(SP)+,R2
1$:	CMPB	#'H,R1
	BEQ	SWHLP
	CMPB	#'N,R1
	BEQ	SWLST
	CMPB	#'M,R1
	BEQ	SWMAC
	CMPB	#'A,R1
	BEQ	ADDCDE		;ADDITIONAL LINES OF CODE
	CMPB	#'C,R1
	BEQ	SWIF
	.PRINT	#SWERR
ESWLOP:	DEC	R0
	BNE	SWLOP
EDSW:	CLR	RBLK			;LIST FILE BLOCK 0
	CLR	PBLK			;LIST FILE BLOCK 0
	CLRB	PSW
	CLRB	LSW
1$:	MOV	#PBUF1,PBUFAD		;SET BUFFER ADDRESSES FOR I/O
	MOV	#LBUF1,LBUFAD
	MOV	#PNUM,PCNT
	MOV	#LNUM,LCNT
	MOV	#1,PASS
	JSR	PC,INITIL		;VARIOUS INTIALISATION
	JSR	PC,L100			;DO PASS 1
	MOV	#2,R1
	JSR	PC,IFCM			;CLEAR ?
	MOV	#4,PASS
	JSR	PC,INITIL		;INITIALISATION
	JSR	PC,L100			;DO PASS 4
	CLRB	STCNT
	JSR	PC,PSYMB	;PRINT SYMBOL TABLE
	MOV	#16.,STCNT
	MOV	TOPAD,R2
	SUB	BOTAD,R2
WRDLP:	MOV	#WRDLB+5,R3
	JSR	PC,INCNT
	DEC	R2
	BEQ	2$
	DEC	R2
	BNE	WRDLP
2$:	MOV	#LNUM-1,R4
	CLR	R1
1$:	JSR	PC,POUT			;OUTPUT LAST BLOCK
	JSR	PC,LOUT
	DEC	R4
	BNE	1$
	.WAIT	#1
	.PRINT	#PERR			;PRINT NUMBER OF ERRORS
	.PRINT	#FRECR			;PRINT FREE CORE
CLOSUP:	.CLOSE	#0			;CLOSE FILES
	.CLOSE	#1
	.CLOSE	#3
	JMP	RPEAT			;BACK FOR MORE
SWHLP:	.PRINT	#HLPTX
	JMP	RPEAT

SWLST:	TST	R1
	BMI	1$
	.PRINT	#SWERR
	JMP	RPEAT
1$:	MOV	R2,LOFL
	BR	ESWLOP

SWMAC:	MOV	#240,MACINS
	BR	ESWLOP

ADDCDE:	MOV	#240,ADDINS
	BR	ESWLOP

SWIF:	MOV	#240,IFINS
	BR	ESWLOP

RIN:	TST	RCNT
	BNE	RFULL
	COMB	RSW
	.WAIT	#3
	BCC	RDOC			;NEED SOME MORE
	JSR	PC,ERRHND		;LOOK FOR TROUBLE
	CLR	RBLK			;REWIND FILE
RDOC:	TSTB	RSW
	BNE	OTHR
	MOV	#RBUF2,RBUFAD		;SET UP POINTER
	.READ	#SRC1,#3,#RBUF1,#RNUM/2,RBLK
	BR	COMR
OTHR:	MOV	#RBUF1,RBUFAD		;SET UP POINTER
	.READ	#SRC2,#3,#RBUF2,#RNUM/2,RBLK
COMR:	BCC	RDOK			;NEED SOME MORE
	JSR	PC,ERRHND		;LOOK FOR TROUBLE
	CLR	RBLK			;REWIND FILE
RDOK:	
	MOV	#RNUM,RCNT		;AND BYTE COUNT
	INC	RBLK		;READ NEXT 10 BLOCKS
RFULL:	MOVB	@RBUFAD,R0
	INC	RBUFAD
	DEC	RCNT
	RTS	PC


POUT:	TST	PCNT
	BNE	PNFULL
	COMB	PSW
	.WAIT	#0
	BCC	PDOC			;NEED SOME MORE
	JSR	PC,ERRHND		;LOOK FOR TROUBLE
PDOC:	TSTB	PSW
	BEQ	POTHR
	MOV	#PBUF2,PBUFAD		;SET UP POINTER
	.WRITE	#HEX1,#0,#PBUF1,#PNUM/2,PBLK
	BR	PCOMB
POTHR:	MOV	#PBUF1,PBUFAD		;SET UP POINTER
	.WRITE	#HEX2,#0,#PBUF2,#PNUM/2,PBLK
PCOMB:	BCC	HXOK
	JSR	PC,ERRDET
HXOK:	INC	PBLK			;MOVE TO NEXT BLOCK
	MOV	#PNUM,PCNT		;RESET POINTER AND COUNT
PNFULL:	MOVB	R1,@PBUFAD
	INC	PBUFAD
	DEC	PCNT
	RTS	PC

LOUT:	TSTB	LFILE
	BEQ	NOLFLE
	TST	LCNT
	BNE	LNFULL
	COMB	LSW
	.WAIT	#1
	BCC	LDOC			;NEED SOME MORE
	JSR	PC,ERRHND		;LOOK FOR TROUBLE
LDOC:	TSTB	LSW
	BEQ	LOTHR
	MOV	#LBUF2,LBUFAD		;SET UP POINTER
	.WRITE	#LST1,#1,#LBUF1,#LNUM/2,LBLK
	BR	LCOMB
LOTHR:	MOV	#LBUF1,LBUFAD		;SET UP POINTER
	.WRITE	#LST2,#1,#LBUF2,#LNUM/2,LBLK
LCOMB:	BCC	LTOK
	JSR	PC,ERRDET
LTOK:	INC	LBLK		;WRITE NEXT TEN BLOCKS
	MOV	#LNUM,LCNT
LNFULL:	MOVB	R1,@LBUFAD
	INC	LBUFAD
	DEC	LCNT
	RTS	PC
	NOP
	NOP
	NOP

NOLFLE:	CMPB	#LF,R1		;NO LIST FILE SO PRINT ERRORS ON TT
	BEQ	1$
	MOVB	R1,@LBUFAD
	INC	LBUFAD
	RTS	PC
1$:	CMPB	#' ,ERRLT
	BEQ	2$
	DEC	LBUFAD
	CLRB	@LBUFAD
	.PRINT	#LBUF1
2$:	MOV	#LBUF1,LBUFAD
	RTS	PC

ERRHND:	TSTB	@#ERRWRD
	BNE	ERRDET			;END OF FILE
	RTS	PC
ERRDET:	BITB	#2,@#ERRWRD
	BNE	PASSIT			;OR FILE NOT FOUND ARE ALLOWED
	.PRINT	#ERRMSG			;ALL ELSE ARE BAD
	JMP	CLOSUP
PASSIT:	RTS	PC


LSTDEV:	2			;CHAN NO. FOR LIST DEVICE OUT
HEXDEV:	1			;CHAN NO. FOR HEX DEVICE OUT
STCKST:	0

RCNT:	0
PCNT:	0
LCNT:	0
RBUFAD:	0
PBUFAD:	0
LBUFAD:	0
RBLK:	0
PBLK:	0
LBLK:	0

SRC1:	.BLKW	10
SRC2:	.BLKW	10
LST1:	.BLKW	10
LST2:	.BLKW	10
HEX1:	.BLKW	10
HEX2:	.BLKW	10

RBUF1:	.BLKW	RNUM/2
RBUF2:	.BLKW	RNUM/2
PBUF1:	.BLKW	PNUM/2
PBUF2:	.BLKW	PNUM/2
LBUF1:	.BLKW	LNUM/2
LBUF2:	.BLKW	LNUM/2

DEFLT:	.RAD50	"880"		;CHAN 3
	.RAD50	"HEX"		;CHAN 0
	.RAD50	"LST"		;CHAN 1
	.WORD	0		;CHAN 2

RSW:	.BYTE	0
PSW:	.BYTE	0
LFILE:	.BYTE	0		;SET IF LIST FILE PRESENT
LSW:	.BYTE	0
TTLE:	.ASCIZ	;8080 ASSEMBLER	(/H FOR HELP);
ERRMSG:	.ASCIZ	/READ-WRITE ERROR/
HLPTX:	.ASCII	;(HEX.HEX),(LIST.LST)<SOURCE.880(/:SWITCHES);<CR><LF>
	.ASCII	;BRACKETS INDICATE OPTIONAL ENTRIES, EXTENSIONS AS ABOVE;<CR><LF>
	.ASCII	;/H	SWITCH LISTING;<CR><LF>
	.ASCII	;/N	NUMBER OF LISTING COLUMNS (DEFAULT 132);<CR><LF>
	.ASCII	;/M	MACROS ARE LISTED;<CR><LF>
	.ASCII	;/A	MULTIPLE LINES OF CODE ARE LISTED;<CR><LF>
	.ASCIZ	;/C	CONDITIONALS ARE LISTED;
SWERR:	.ASCIZ	/SWITCH ERROR/
	.ODD
FRECR:	.ASCII	/FREE CORE  /
WRDLB:	.ASCIZ	/      WORDS/
	.EVEN

Q1:	.BLKW	7*5
ILOP:	MOVB	#'0,(R3)
INCNT:	INCB	-(R3)		;ENTRY-COUNTS IN DECIMAL
	CMPB	(R3),#':
	BEQ	ILOP
	RTS	PC

INITIL:	CLRB	LFILE
	.WAIT	#1
	BCS	1$
	INCB	LFILE
1$:	MOVB	#1,PNCST
	MOV	#"00,R1
	MOV	R1,WRDLB
	MOV	R1,WRDLB+2
	MOV	R1,PGNO
	MOV	R1,PGNO+2
	MOV	R1,ERCNT
	MOV	R1,ERCNT+2
	MOV	#ETIT-TITL,TITCNT
	CLR	RBLK
	CLRB	RSW
	.READ	#SRC1,#3,#RBUF1,#RNUM/2,RBLK
	INC	RBLK
	CLR	RCNT
	RTS	PC

TABOFF	=	0
PSYMB:	MOV	#ETT-TOPFM-1,R1
	CLR	R2
	CLR	R0
1$:	INC	R0
	ADD	R1,R2
	CMP	R2,LOFL
	BCS	1$
	DEC	R0
	MOV	R0,OP2
	MOV	SYMB5+TABOFF,TSTR3
NEWPG:	JSR	PC,CRLF
	MOV	#60.,OP1
	MOV	#14,R1
	JSR	PC,LISTX
	JSR	PC,PNTTT
	JSR	PC,CRLF
	MOV	OP2,TSTR2
2$:	MOV	#ETT-TOPFM-1,TSTR1
	MOV	#TOPFM,TSTR4
1$:	MOVB	@TSTR4,R1
	INC	TSTR4
	JSR	PC,LISTX
	DEC	TSTR1
	BNE	1$
	DECB	TSTR2
	BNE	2$
	JSR	PC,CRLF
NEWLN:	JSR	PC,CRLF
	MOV	#' ,R1
	JSR	PC,LISTX
	MOV	OP2,TSTR4
NWSYMB:	CMP	TSTR3,SYMB4+TABOFF
	BCS	3$
	JSR	PC,CRLF
	RTS	PC
3$:	MOV	#5,TSTR2
4$:	MOVB	@TSTR3,R1
	JSR	PC,LISTX
	INC	TSTR3
	DEC	TSTR2
	BNE	4$
	MOVB	@TSTR3,R0
	INC	TSTR3
	MOV	#TMAC,TSTR1
	CMPB	#40,R0
	BEQ	1$
	MOV	#TMUL,TSTR1
	CMPB	#3,R0
	BEQ	1$
	MOV	#TEQU,TSTR1
	CMPB	#2,R0
	BEQ	1$
	MOV	#TSET,TSTR1
	CMPB	#4,R0
	BEQ	1$
	MOV	#TOTH,TSTR1
1$:	MOV	#7,TSTR2
2$:	MOVB	@TSTR1,R1
	INC	TSTR1
	JSR	PC,LISTX
	DECB	TSTR2
	BNE	2$
	MOV	@TSTR3,R1
	JSR	PC,DLISTA
	INC	TSTR3
	INC	TSTR3
	MOV	#' ,R1
	JSR	PC,LISTX
	MOV	#' ,R1
	JSR	PC,LISTX
	DECB	TSTR4
	BNE	NWSYMB
	DECB	OP1
	BNE	NEWLN
	JMP	NEWPG

TOPFM:	.ASCII	/ SYMBOL TYPE VALUE /
ETT:
TEQU:	.ASCII	/  EQU  /
TOTH:	.ASCII	/  OTH  /
TSET:	.ASCII	/  SET  /
TMAC:	.ASCII	/  MAC  /
TMUL:	.ASCII	/ *MUL* /
	.EVEN

PDATE:	.DATE
	MOV	R0,R1
	BEQ	EDATE
	BIC	#177740,R0
1$:	MOV	#YEAR+2,R3
	JSR	PC,INCNT
	DECB	R0
	BNE	1$
	ASR	R1
	ASR	R1
	MOV	R1,R0
	ASR	R0
	ASR	R0
	ASR	R0
	BIC	#177740,R0
2$:	MOV	#DAY+2,R3
	JSR	PC,INCNT
	DECB	R0
	BNE	2$
	SWAB	R1
	BIC	#177740,R1
	MOV	R1,R0
	ASL	R0
	ADD	R1,R0
	ADD	#MNTAB-3,R0
	MOVB	(R0)+,MNTH
	MOVB	(R0)+,MNTH+1
	MOVB	(R0),MNTH+2
EDATE:	RTS	PC

MNTAB:	.ASCII	/JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC/
	.EVEN
LIST:;	CMP	#' ,ERRLT
;	BNE	LISTX
	TSTB	IFSW
IFINS:	BNE	L144
	TSTB	MACSW
MACINS:	BNE	L144
	TSTB	PNCST
ADDINS:	BEQ	L144
LISTX:	MOV	#LSTST,R3
	CMPB	#LF,R1
	BNE	L146
	MOV	#LSTBUF,R2
	MOV	R2,3(R3)
	TSTB	(R3)
	BEQ	L142
L140:	MOVB	(R2)+,R1
	JSR	PC,LOUT
	DECB	(R3)
	BNE	L140
L142:	MOVB	(R3)+,(R3)+
	MOVB	#16.,(R3)
STCNT	=	.-2
	MOVB	#CR,R1
	JSR	PC,LOUT
	MOVB	#LF,R1
	JSR	PC,LOUT
L144:	RTS	PC
L146:	INC	R3
	CMPB	#CR,R1
	BNE	L148
	INCB	(R3)
	RTS	PC
L148:	CMPB	#14,R1
	BEQ	L149
	TSTB	(R3)+
	BEQ	L150
L149:	JSR	PC,LOUT
	RTS	PC
L150:	INCB	(R3)
	CMPB	#'	,R1
	BNE	L152
	MOVB	(R3),R0
	ADD	#7,R0
	BIC	#7,R0
	MOVB	R0,(R3)
L152:	CMPB	#132.,(R3)+
LOFL	=	.-2
	BCS	L144
	MOVB	R1,@(R3)
	INC	(R3)
	INCB	LSTST
	RTS	PC
LSTBUF:	.BLKB	132.


ERROR:				; ERROR ROUTINE  STORAGE FOR ERROR ROUTINE
	MOVB	IFSW,R0		;CURRENT ASSEMBLY STATUS (IF)
	RORB	R0
	MOVB	ERRLT,R2	;CODE LETTER FOR ERROR
	SUB	#' ,R2
	SUB	#1,R2
	MOVB	#0,R2
	SBCB	R2
	BICB	R0,R2
	RORB	R2
	BCC	L170
	MOVB	R1,ERRLT	;CODE LETTER FOR ERROR
	MOV	#ERCNT+4,R3
	JSR	PC,INCNT
L170:	RTS	PC

LUKUP:			;LOOKS UP PARM IN TABLE	;STORAGE FOR LUKUP ROUTINE
	MOVB	R2,R3
	RORB	R3
	BIC	#177400,R3
	ADD	R1,R3
	MOVB	(R3),R0
	BIT	#1,R2
	BEQ	L175
	RORB	R0
	RORB	R0
	RORB	R0
	RORB	R0
L175:	BIC	#-16.,R0
	RTS	PC
HXTOA:				;CONVERTS LOWER NIBBLE IN R1 TO ASCCI
	BIC	#-16.,R1
	ADD	#'0,R1
	CMPB	#'9,R1
	BCC	L180
	ADD	#7,R1
L180:	RTS	PC

PUNCH:			;STORAGE FOR PUNCH ROUTINE
	MOV	R1,-(SP)
	ASRB	R1
	ASRB	R1
	ASRB	R1
	ASRB	R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,POUT	;MONITOR PUNCH
	MOV	(SP)+,R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,POUT	;MONITOR PUNCH
	RTS	PC

DLISTA:	MOV	R1,-(SP)
	SWAB	R1
	JSR	PC,LISTA
	MOV	(SP)+,R1
LISTA:			;STORAGE FOR LISTA ROUTINE
	MOV	R1,-(SP)
	ASRB	R1
	ASRB	R1
	ASRB	R1
	ASRB	R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,LIST	;LISTING SUBROUTINE
	MOV	(SP)+,R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,LIST	;LISTING ROUTINE
	RTS	PC

PRCRD:	MOVB	R1,RCTYP	;PUNCHED RECORD TYPE
	MOVB	#':,R1
	JSR	PC,POUT	;MONITOR PUNCH
	MOVB	RCLEN,R1	;LENGTH OF PUNCHED RECORD
	JSR	PC,PUNCH	;PUNCHES <C>
	MOVB	RCADR+1,R1	;LOADING ADDRESS OF PUNCHED RECORD
	JSR	PC,PUNCH	;PUNCHES <C>
	MOVB	RCADR,R1	;LOADING ADDRESS OF PUNCHED RECORD
	JSR	PC,PUNCH	;PUNCHES <C>
	MOVB	RCTYP,R1	;PUNCHED RECORD TYPE
	JSR	PC,PUNCH	;PUNCHES <C>
	MOVB	#1,ML23
L190:	MOV	#ML23,R3
	CMPB	RCLEN,(R3)
	BCS	L185
	MOVB	(R3),R2
	ADD	#RCDAT,R2	;DATA AREA FOR DATA FOR PUNCHING
	MOVB	(R2),R1
	JSR	PC,PUNCH	;PUNCHES <C>
	INCB	ML23
	BNE	L190
L185:	MOVB	RCADR+1,R2	;LOADING ADDRESS OF PUNCHED RECORD
	MOVB	RCSUM,R1	;SUM OF CHARACTERS IN PUNCHED RECORD
	SUB	R2,R1
	SUB	RCADR,R1	;LOADING ADDRESS OF PUNCHED RECORD
	SUB	RCTYP,R1	;PUNCHED RECORD TYPE
	SUB	RCLEN,R1	;LENGTH OF PUNCHED RECORD
	MOVB	R1,RCLEN+1
	JSR	PC,PUNCH	;PUNCHES <C>
	MOVB	#CR,R1
	JSR	PC,POUT	;MONITOR PUNCH
	MOVB	#LF,R1
	JSR	PC,POUT	;MONITOR PUNCH
	MOV	#RCSUM,R3	;SUM OF CHARACTERS IN PUNCHED RECORD
	CLRB	(R3)
	CLRB	-(R3)		;NUMBER OF CHARS TO BE PUNCHED
	MOVB	#16.,-(R3)		;MAX NUMBER OF CHARS PUNCHED
	RTS	PC
INSDC:	MOVB	R1,IDCST	;STORAGE FOR S37 ROUTINE-CODES INSTRUCTIONS
	BIT	#3,R1
	BEQ	L195
	MOV	#OP2,R3
	CMP	#7,(R3)
	BCS	2$		;REGISTER VALUE MUST BE LESS THAN 8
	BITB	#1,(R3)
	BEQ	1$		;TEST FOR REGISTER PAIR INSTRUCTION
	BITB	#1,R1
	BNE	2$
1$:	BIC	#-4,R1
	CMPB	#3,R1		;TEST FOR LDAX INSTUCTION
	BNE	L200
	CMPB	#2,(R3)
	BCC	L200
2$:	CLRB	(R3)
	MOVB	#'R,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L200:	BITB	#4,IDCST	;STORAGE FOR	S37 ROUTINE	;
	BEQ	L205
	MOV	#OP2,R3	;SECOND OPERAND
	CLC
	ROLB	(R3)
	ROLB	(R3)
	ROLB	(R3)
L205:	BISB	OP2,OP1
L195:	BITB	#10,IDCST	;STORAGE FOR	S37 ROUTINE	;
	BEQ	L210
	MOVB	OP2M,R0
	INCB	R0
	CMPB	#1,R0
	BCC	L210
	MOVB	#'V,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L210:	MOVB	#4,R1
	MOVB	IDCST,R0	;STORAGE FOR	S37 ROUTINE	;
L215:	CLC
	RORB	R0
	DECB	R1
	BNE	L215
	ADD	#'",R0
	MOVB	R0,MD27
	SUB	#'",R0
	BNE	L220
	TSTB	OP1M		;UPPER BYTE OF FIRST OPERAND
	BEQ	L225
	MOVB	#'V,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L225:	MOVB	#6,ML26
L220:	RTS	PC
SHIFT:	MOV	TSTR4,R3
	MOV	TSTR3,R2
	MOV	(R3),(R2)
	MOV	10.(R3),10.(R2)
	MOV	20.(R3),20.(R2)
	MOV	30.(R3),30.(R2)
	MOV	40.(R3),40.(R2)
	RTS	PC

IFCM:	MOVB	R1,S17ST	;DEALS WITH IF COMMAND ?	;STORE FOR <S17>
	CMPB	R1,STK2A
	BEQ	L240
	MOV	#S17ST,R3	;STORE FOR <S17>
	MOVB	(R3),R0
	SUB	#-1,R0
	SUB	#1,R0
	MOVB	#0,R0
	SBCB	R0
	BIC	#-6,R0
	ADD	#'N,R0		;N OR S ERROR
	MOVB	R0,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	MOV	#IFCNT,R3	;COUNT OF NUMBER OF IF COMMANDS
	CMPB	#1,(R3)
	BCC	L245
	MOVB	#2,(R3)
L245:	MOV	#ML99,R3	;LOADING ADDRESS OF PUNCHED RECORD
	CMPB	#1,(R3)
	BCC	L240
	MOVB	#2,(R3)
L240:	CMPB	#1,ML99
	BCC	1$
	TSTB	STK2A		;SECOND STACK - A
	BNE	2$
1$:	CMPB	#2,S17ST	;STORE FOR <S17>
	BNE	L250
2$:	MOV	SYMB3,TOPAD	;INCREASING WORK SPACE
	MOVB	ML99,R0		;LOADING ADDRESS OF PUNCHED RECORD
	ASL	R0
	MOV	#SYMB1,R1
	MOV	R1,TSTR3
	ADD	R0,R1
	MOV	R1,TSTR4
	JSR	PC,SHIFT	;FOUR NUMBERS SEPARATED BY 10 MOVED <<TSTR4>> TO <<TSTR3>>
	MOV	#ML99,R3	;LOADING ADDRESS OF PUNCHED RECORD
	DECB	(R3)
	CMPB	#1,(R3)+
	MOVB	#0,(R3)
	SBCB	(R3)
	CLRB	MCRSW
L250:	MOV	#IFCNT,R3	;COUNT OF NUMBER OF IF COMMANDS
	CMPB	#1,(R3)
	BCC	L255
	MOVB	(R3),R1
	ADD	#IFSW,R1		;CURRENT ASSEMBLY STATUS (IF)
	MOVB	(R1),IFSW		;CURRENT ASSEMBLY STATUS (IF)
	MOVB	(R3)+,R1
	ADD	R3,R1
	MOVB	(R1),(R3)
	DECB	-(R3)
L255:	RTS	PC
EIFCM:	MOVB	R1,ML33		;DEALS WITH ENDIF COMMAND ?
	TSTB	EXIT		;SET FOR END OF ASSEMBLY
	BNE	L265
	MOV	#IFCNT,R3	;COUNT OF NUMBER OF IF COMMANDS
	INCB	(R3)
	CMPB	(R3),#8.
	BCS	L260
	MOVB	#-1,R1
	JSR	PC,IFCM	;DEALS WITH IF COMMAND ?
	BR	L265
L260:	TSTB	ML33
	BEQ	L270
	MOV	#ML99,R3	;LOADING ADDRESS OF PUNCHED RECORD
	INCB	(R3)
	CMPB	(R3),#5
	BCS	L275
	MOVB	#-1,R1
	JSR	PC,IFCM	;DEALS WITH IF COMMAND ?
	BR	L270
L275:	MOVB	(R3),R0
	ASL	R0
	MOV	#SYMB1,R2
	MOV	R2,TSTR4
	ADD	R0,R2
	MOV	R2,TSTR3
	JSR	PC,SHIFT	;FOUR NUMBERS SEPARATED BY 10 MOVED <<TSTR4>> TO <<TSTR3>>
	MOV	TOPAD,SYMB3	;INCREASING WORK SPACE
	MOV	#BOTAD,R3	;DECREASING WORK SPACE
	CMP	(R3)+,TOPAD
	BCS	L280
	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	BR	L270
L280:	MOVB	(R3),R1		;PASS NUMBER
	DECB	R1
	BNE	L285
	MOV	SYMBX,R3	;END OF SYMBOL TABLE
	MOV	#2,(R3)+
	MOV	R3,BOTAD	;DECREASING WORK SPACE
L285:	CMP	BOTAD,SYMBX
	BCC	L290
	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	BR	L270
L290:	MOV	SYMBX,R3	;END OF SYMBOL TABLE
	ADD	#2,R3
	MOV	R3,SYMB5
	MOV	SYMBX,R3	;END OF SYMBOL TABLE
	ADD	@SYMBX,R3
	MOV	R3,SYMB4	;CONTAINS END OF PROGRAM ADDRESS
	CMPB	#3,ML33
	BEQ	L270
	MOV	SYMB4,SYMBX	;END OF PROG ADDRESS TOEND OF SYMBOL TABLE ADDRESS
L270:	MOVB	IFCNT,R2	;COUNT OF NUMBER OF IF COMMANDS
	ADD	#IFSW,R2	;CURRENT ASSEMBLY STATUS (IF)
	MOVB	IFSW,(R2)	;CURRENT ASSEMBLY STATUS (IF)
	MOVB	IFCNT,R2	;COUNT OF NUMBER OF IF COMMANDS
	ADD	#STK2A,R2
	MOVB	STK2A,(R2)	;SECOND STACK - A
	MOVB	ML33,STK2A
L265:	RTS	PC
READ:	TSTB	CHRCT		;COUNT OF CHARS AVAILABLE
	BEQ	L295
	TSTB	MACSW
	BEQ	L300		;JUMP IF NOT MACRO
L325:	INC	SYMB2
	MOV	#CHRIN,R3	;INCOMING CHARACTER
	MOVB	@SYMB2,(R3)
	CMPB	#MCEND,(R3)	;MACRO TERMINATION IN MEMORY CHARACTER
	BEQ	L295		;JUMP IF NOT MACRO PARAMETER
	CMPB	#127.,(R3)
	BCC	L305		;JUMP IF NOT MACRO EXPANSION
	MOV	#MS14,R3
	TSTB	(R3)
	BEQ	L310
	CLRB	(R3)+		;CLEAR <MS14>
	MOV	(R3),SYMB2
	BR	L325		;<SYMB2> = <SYMB1>
L310:	MOV	SYMB2,SYMB1
	MOV	SYMB3,SYMB2	;<SYMB2> = <SYMB3>
	MOVB	#1,MS14
L320:	MOV	#CHRIN,R3	;INCOMING CHARACTER
	DECB	(R3)
	CMPB	(R3),#128.
	BCS	L325
	MOVB	@SYMB2,R0
	BIC	#-128.,R0
	SUB	R0,SYMB2
	BR	L320
L300:	JSR	PC,RIN
	BIC	#-127.-1,R0
	MOV	#CHRIN,R3	;INCOMING CHARACTER
	MOVB	R0,(R3)
	BEQ	L300
	CMPB	#LF,R0
	BEQ	L300
	CMPB	#127.,R0
	BEQ	L300		;IGNORE 0,LF OR DELETE
L305:	BITB	#1,PASS
	BNE	L330		;LIST CHAR IF PASS 2 OR 4
	MOVB	CHRIN,R1
	JSR	PC,LIST	;LISTING ROUTINE
L330:	CMPB	#1,PASS
	BNE	L295
	TSTB	MCRSW
	BEQ	L295
	MOV	SYMB2,R0		;STORAGE POSITION FOR STORING MACROS
	MOVB	CHRIN,(R0)+
	MOV	R0,SYMB2
	SUB	TOPAD,R0
	BCS	L295
	CLRB	MCRSW		;READING MACROS SWITCH
L295:	MOVB	#1,CHRCT	;COUNT OF CHARS AVAILABLE
	MOV	#CHRIN,R3	;INCOMING CHARACTER
	MOVB	(R3),-(R3)
	MOVB	(R3)+,R0
	RTS	PC
TAB1:	.BYTE	0
	.BYTE	0
	.BYTE	0
	.BYTE	0
	.BYTE	16.	;TAB
	.BYTE	0	;
	.BYTE	74.	;CR & FF
	.BYTE	0	;			0000 = ILLEGAL
	.BYTE	0	;			0001 = TAB
	.BYTE	0	;			0002 = ;
	.BYTE	0	;			0003 = :
	.BYTE	0	;			0004 = CR
	.BYTE	0	;			0005 = ()*+,-/
	.BYTE	0	;			0006 = $
	.BYTE	0	;			0007 = '
	.BYTE	0	;			0008 = DIGITS
	.BYTE	1	;SPACE			0009 = LETTERS
	.BYTE	0	;			0010 = FORM FEED
	.BYTE	6	;$
	.BYTE	112.	;'
	.BYTE	85.	;()
	.BYTE	85.	;*+
	.BYTE	85.	;,-
	.BYTE	80.	;/
	.BYTE	136.	;10
	.BYTE	136.	;32
	.BYTE	136.	;54
	.BYTE	136.	;76
	.BYTE	136.	;98
	.BYTE	35.	;:;
	.BYTE	0
	.BYTE	0

RDLUP:			;READS AND LOOKS UP INCOMING CHAR IN ITS TABLE
	JSR	PC,READ	;READING SUBROUTINE
	CMPB	#'Z,R0
	BCC	L340
	CLR	R0
	RTS	PC

L340:	CMPB	#'>,R0
	BCC	L345
	MOV	#'	,R0
	RTS	PC

L345:	MOV	#TAB1,R1
	MOVB	R0,R2
	JSR	PC,LUKUP	;LOOKS UP PARM IN TABLE
	RTS	PC
MOVEM:	MOV	#TOPAD,R3	;MOVES DATA INTO MEMORY FOR MACROS?
L365:	CMP	R2,R1
	BCS	L350
	CMP	BOTAD,(R3)
	BCS	L355
	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L350:	MOV	#TOPAD,R3	;INCREASING WORK SPACE
	MOV	(R3),R1
	RTS	PC
L355:	MOVB	(R2),@(R3)
	DEC	(R3)
	DEC	R2
	BR	L365

STSTK:	MOVB	R1,STKST	;DATA ON STACKS IS PUSHED DOWN	;STORE FOR <STSTK>
	MOV	#DISP,R3	;DISPLACEMENT ON STACKS
	INCB	(R3)
	CMPB	#8.,(R3)
	BNE	L370
	MOVB	#2,(R3)
	MOVB	#'S,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L370:	MOV	#DISP,R3	;DISPLACEMENT ON STACKS
	MOVB	(R3)+,R2
	MOV	#16.,R1
	MOV	R3,R0
	ADD	R2,R3
	ADD	R2,R3
	MOV	(R0),(R3)
	ADD	R1,R0
	ADD	R1,R3
	MOV	(R0),(R3)
	CLR	(R0)
	ADD	R1,R0
	ADD	R1,R3
	SUB	R2,R3
	MOVB	(R0),(R3)
	MOVB	STKST,(R0)
	ASR	R1
	ADD	R1,R0
	ADD	R1,R3
	MOVB	(R0),R1
	MOVB	R1,(R3)
	CLRB	(R0)
	ADD	R1,STK1A
	RTS	PC

DSTCHR:	MOV	R1,-(SP)
	JSR	PC,STCHR
	MOV	(SP)+,R1
	SWAB	R1
STCHR:	MOV	#STK1D,R3	;STORES ONE CHAR ON STACK - STK1D	;STORE FOR <STCHR>
	MOVB	(R3),R0
	ADD	STK1A,R0	;STACK ONE
	CMP	R0,MD24
	BCC	L375
	MOVB	R1,(R0)
	INCB	(R3)
	RTS	PC
L375:	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L380:	RTS	PC
UNSTK:	MOV	#DISP,R3	;MOVES DATA OFF STACKS
	MOVB	(R3),R1
	DECB	(R3)+
	ADD	R1,R3
	ADD	R1,R3
	MOV	(R3),STK1A
	MOV	16.(R3),STK1B
	SUB	R1,R3
	MOVB	32.(R3),STK1C
	MOVB	40.(R3),STK1D
	RTS	PC

RDSTR:	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN AND R1 STORED ON STK1C
	DECB	CHRCT
L395:	JSR	PC,RDLUP	;READS AND LOOKS UP INCOMING CHAR IN ITS TABLE
	CMPB	#7,R0
	BCC	L385
	MOV	#CHAR2,R3	;SECONDARY STORE FOR INCOMING CHAR
	CMPB	#'@,(R3)
	BCC	L390		;JUMP IF LETTER
	BICB	#-224.,(R3)
L390:	MOVB	(R3),R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	BR	L395
L385:	DECB	CHRCT	;COUNT OF CHARS AVAILABLE
	RTS	PC
			;PRIORITY OF OPERATORS
TAB2:	.BYTE	0
	.BYTE	0
	.BYTE	103.		;*	+
	.BYTE	97.		;F ERR	-
	.BYTE	118.		;L&P	\
	.BYTE	86.		;NEG	NOT
	.BYTE	52.		;&	OR
	.BYTE	115.
	.BYTE	119.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	0
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	17.
	.BYTE	5*16.+5.	;LOW
	.EVEN

TABLK:	MOVB	R1,R2		;LOOKS UP <C> IN ITS TABLE
	MOV	#TAB2,R1
	JSR	PC,LUKUP	;LOOKS UP PARM IN TABLE
	RTS	PC
FIND:	MOV	#SYMB5,R3
	ASL	R1
	ADD	R1,R3
	MOV	(R3),R2
	ADD	#SYMB4,R1	;CONTAINS END OF PROGRAM ADDRESS
	MOV	(R1),R4		;HOLDS ADDRESS OF COMPILED CODE
	MOV	(R1),R3
	MOV	STK1A,R1
L430:	MOV	R3,R5
	SUB	R2,R5
	ROR	R5
	BIC	#100007,R5
	ADD	R2,R5
	CMP	R5,R4
	BEQ	L400
	MOV	R5,R4		;ADDRESS OF END OF COMPILED CODE
	MOV	R1,R5		;STACK ONE
L410:	CMPB	(R4)+,(R5)+
	BNE	L405
	MOVB	STK1D,R0	;STACK FOUR
	ADD	R1,R0		;STACK ONE
	CMP	R5,R0
	BNE	L410
	CMPB	#' ,(R4)
	BEQ	2$
	CMPB	#5,STK1D	;STACK FOUR
	BNE	L405
2$:	MOVB	STK1D,R0
	SUB	R0,R4
	MOV	R4,STK1B	;STACK TWO
	MOVB	5(R4),R0
	MOVB	R0,STK1C
	CMPB	#'*,R0
	BNE	L420
	CMPB	#'",R0
	BNE	L420
	CMPB	#19.,R0
	BNE	L420
	CMPB	#20.,R0
	BNE	L420
	CMPB	#24.,R0
	BNE	L420
	CMPB	#29.,R0
	BNE	L420
	CMPB	#30.,R0
	BNE	L420
	MOVB	#1,OP4		;CONTAINS END OF PROGRAM ADDRESS
L420:	RTS	PC		;R0 HAS STK1C IN IT
L405:	MOV	R4,R0
	SUB	R5,R0
	ADD	R1,R0	;STACK ONE
	CMPB	-(R4),-(R5)
	BPL	1$
	MOV	R0,R2
	MOV	R0,R4
	BR	L430
1$:	MOV	R0,R3
	MOV	R0,R4
	BR	L430
L400:	MOV	R3,STK1B
	CLR	R0
	RTS	PC
INSERT:	MOV	#ML51,R3
	MOVB	R1,(R3)+
	MOVB	R2,(R3)
	CMPB	#1,DISP		;DISPLACEMENT ON STACKS
	BEQ	L435
	MOVB	#'F,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	JMP	L440
L435:	MOV	#STK1C,R3	;STACK THREE
	TSTB	(R3)
	BEQ	1$
	JMP	L445
1$:	MOV	BOTAD,R1	;DECREASING WORK SPACE
	MOV	R1,TSTR4
	ADD	#8.,R1
	MOV	R1,TSTR3
	SUB	TOPAD,R1	;INCREASING WORK SPACE
	BCS	L450
	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	JMP	L455
L450:	MOV	TSTR3,BOTAD
	CMPB	#3,STK2A	;SECOND STACK - A
	BEQ	L460
	ADD	#8.,SYMBX	;END OF SYMBOL TABLE
L460:	MOVB	ML53,R2
	ASL	R2
	MOV	R2,R1
	ADD	#SYMB4,R1	;CONTAINS END OF PROGRAM ADDRESS
	ADD	#8.,(R1)
	ADD	#SYMB5,R2
	MOV	(R2),R3
	DEC	R3
	DEC	R3
	MOV	R3,TSTR2	;HOLDS ADDRESS OF COMPILED CODE
	ADD	#8.,(R3)
L470:	MOV	#ML53,R3
	MOVB	(R3),R1
	INCB	R1
	CMPB	ML99,(R3)
	MOVB	#0,R0
	SBCB	R0
	COMB	R0
	COMB	R1
	BICB	R1,R0
	MOVB	R0,(R3)
	DECB	R0
	BEQ	L465
	MOVB	(R3),R2
	ASL	R2
	MOV	R2,R1
	ADD	#SYMB5,R1
	ADD	#8.,(R1)
	ADD	#SYMB4,R2	;CONTAINS END OF PROGRAM ADDRESS
	ADD	#8.,(R2)
	BR	L470
L465:	MOV	TSTR4,R0
	MOV	TSTR3,R1
	MOV	STK1B,R2
	CMP	(R0)+,(R1)+
L466:	MOV	-(R0),-(R1)
	CMP	R0,R2
	BCC	L466
	MOV	STK1B,R3
	MOV	#"  ,(R3)
	MOV	#"  ,2(R3)
	MOVB	#' ,4(R3)
	MOV	STK1A,R2
	MOVB	STK1D,R0
L490:	MOVB	(R2)+,(R3)+
	DEC	R0
	BNE	L490
	MOVB	ML51,STK1C	;STACK THREE
	BR	L495
L445:	CMPB	#1,PASS
	BNE	L505		;JUMP IF NOT PASS 1
	CMPB	#4,(R3)		;IS IT EQUATE SYMBOL
	BNE	1$
	CMPB	(R3),ML51
	BEQ	L505		;DO SYMBOL TYPES CORRESPOND
1$:	MOVB	#3,(R3)		;MULTIPLE DEFINITION
	BR	L495
L505:	CMPB	#4,(R3)		;STACK THREE
	BEQ	L495
	MOV	STK1B,R3	;STACK TWO
	CMP	EQUST,6(R3)
	BEQ	L495
	MOVB	STK1C,R1
	SUB	#3,R1
	ADD	#-1,R1
	MOVB	#0,R1
	SBCB	R1
	BIC	#-4,R1
	ADD	#'M,R1		;M OR P ERROR
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L495:	MOV	STK1B,R3	;STACK TWO
	MOVB	STK1C,5(R3)	;STACK THREE
	CMPB	STK1C,ML51
	BNE	L455
	MOV	EQUST,6(R3)	;EQUATE STORE
L455:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
L440:	RTS	PC
S30:	CLR	OP1		;DTSTR1S OPERANDS FOR INSTRUCTIONS
	CMPB	DISP,#1		;DISPLACEMENT ON STACKS
	BCC	L510
	MOVB	#'F,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	BR	L515
L510:	TSTB	STK1C		;STACK THREE
	BNE	L520
	CMPB	1,ML99
	BCS	L520
	MOVB	#2,R1
	JSR	PC,FIND
	MOVB	R0,STK1C	;STACK THREE
L520:	MOV	#STK1C,R3	;STACK THREE
	TSTB	(R3)
	BNE	L525
	MOVB	#'U,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	BR	L530
L525:	CMPB	#4,(R3)
	BCS	L535
	MOV	STK1B,R3	;STACK TWO
	ADD	#6,R3
	MOV	R3,STK1A	;STACK ONE
	MOVB	#2,STK1D	;STACK FOUR
	BR	L540
L535:	CMPB	#2,STK1D	;STACK FOUR
	BCC	L540
	MOVB	#'V,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L540:	MOVB	@STK1A,OP1	;STACK ONE
	CMPB	#1,STK1D
	BCC	L545
	MOV	STK1A,R3	;STACK ONE
	INC	R3
	MOVB	(R3),OP1M
L545:	CMPB	#5,STK1C	;STACK THREE
	BNE	L530
	BITB	#1,OP4		;CONTAINS END OF PROGRAM ADDRESS
	BNE	L530
	CMPB	#2,STK1D	;STACK FOUR
	BNE	L530
	MOV	#OP1,R3		;FIRST OPERAND
	MOV	#OP3,R2
	MOVB	(R3)+,(R2)
	MOVB	(R3),-(R3)
	INC	R3
	MOVB	(R2),(R3)
L530:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
L515:	MOV	#OP1,R3	;FIRST OPERAND
	MOV	(R3)+,R1
	RTS	PC

L100:	CLRB	ML27		;INITIAL CODING - CLEAR CHARACTER COUNT
	CLRB	MCRSW	;READING MACROS SWITCH
	MOV	#OP3M,R3
	CLRB	(R3)+
	CLRB	(R3)
	CLRB	IFSW		;CURRENT ASSEMBLY STATUS (IF)
	CLR	LSTPC		;PROGRAM COUNTER
	CLRB	ML69
	MOV	#TAB5,SYMB5
	MOV	#FREE,SYMB4	;CONTAINS END OF PROGRAM ADDRESS
	MOV	FREE,SYMBX	;END OF PROGRAM ADDRESS
	CMPB	#1,PASS
	BNE	MNPRG
	.SETTOP	#-2		;MONITOR MEMORY SIZE
	MOVB	#MCEND,(R0)	;MACRO TERMINATION IN MEMORY CHARACTER
	DEC	R0
	MOV	R0,TOPAD	;INCREASING WORK SPACE
	MOV	R0,EOFM		;INCREASING WORK SPACE
	MOV	SYMB4,BOTAD	;CONTAINS END OF PROGRAM ADDRESS
MNPRG:	MOVB	#' ,ERRLT	;STORE FOR ERROR LETTER
	MOVB	#CR,CHRIN	;INCOMING CHARACTER
	CLR	RCLEN		;LENGTH OF PUNCHED RECORD
	CLRB	RCLEN+2
	MOV	#LSTST,R3	;COUNT OF CHARS AVAILABLE
	CLRB	(R3)+
	CLRB	(R3)+
	MOVB	#16.,(R3)+
	MOV	#LSTBUF,(R3)
	CLRB	DISP		;DISPLACEMENT ON STACKS
	CLRB	IFCNT		;COUNT OF NUMBER OF IF COMMANDS
	CLRB	ML99		;LOADING ADDRESS OF PUNCHED RECORD
	CLRB	STK1D		;STACK FOUR
	CLRB	STK1C		;STACK THREE
	CLR	ML67
	MOVB	#16.,RCMAX	;MAXIMUM PUNCHED RECORD LENGTH
	CLRB	MCRSW		;READING MACROS SWITCH
	CLR	MACSW
	MOVB	#2,R1
	JSR	PC,EIFCM	;DEALS WITH ENDIF COMMAND ?
	CLR	PCX		;PROGRAM COUNTER
	CLR	RCADR		;LOADING ADDRESS OF PUNCHED RECORD
	MOV	#TBUFF,STK1A	;BUFF FOR INCOMING PSEUDO INSTRUCTIONS
	MOV	#TAB5,MD24
	MOVB	#1,ML61
L600:	TSTB	ML61		;END OF FIRST T ROUTINES
	BNE	L550
	MOVB	#'E,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L550:	CLRB	ML61
L565:	JSR	PC,RDLUP	;READS AND LOOKS UP INCOMING CHAR IN ITS TABLE
	MOV	R0,R3
	BIC	#177400,R3
	JMP	L555

T9:	BITB	#1,PASS
	BNE	L565
	JSR	PC,PNTTT
	BR	L565

PNTTT:	MOV	#PGNO+4,R3
	JSR	PC,INCNT
	MOV	#TITL,R4
	MOV	TITCNT,R5
	CLRB	LSTST+2
1$:	MOVB	(R4)+,R1
	JSR	PC,LISTX
	DECB	R5
	BNE	1$
CRLF:	MOVB	#CR,R1
	JSR	PC,LISTX
	MOVB	#LF,R1
	JSR	PC,LISTX
	RTS	PC

TITL:	.ASCII	/ /
DAY:	.ASCII	/00-/
MNTH:	.ASCII	/JUP-/
YEAR:	.ASCII	/72,/
	.ASCII	/  PAGE /
PGNO:	.ASCII	/0000,  8080 ASSEMBLER, /
PERR:	.ASCII	/ERRORS /
ERCNT:	.ASCII	/0000/<0>/, /
ETIT:	.BLKB	51.
	.EVEN
TITCNT:	.WORD

T10:	CMPB	CHAR2,#MCEND	;SECONDARY STORE FOR INCOMING CHAR * ILLEGAL CHARACTERS *
	BNE	1$
	TSTB	MACSW
	BNE	L572
1$:	MOVB	#'I,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
T11:	BR	L565	;					* SPACE AND TAB
			;READS UNTIL TERMINATOR
T12:	JSR	PC,RDLUP	;READS AND LOOKS UP INCOMING CHAR IN ITS TABLE
	CMPB	#4,R0	;					* COMMENTS *,R0
	BNE	T12
T14:	MOVB	#1,CHAR2	;SECONDARY STORE FOR INCOMING CHAR	* CARRIAGE RETURN *
L572:	JMP	L560

T13:	MOVB	#1,ML61	;					* COLON *
	CLRB	ML27
	JSR	PC,READ	;READING SUBROUTINE
	SUB	#':,R0
	BEQ	L575
	DECB	CHRCT
	BR	L580
L575:	CMPB	#1,ML99
	BCC	L580
	MOVB	#2,ML27
	MOVB	#2,R1
	JSR	PC,FIND
	MOVB	R0,STK1C	;STACK THREE
L580:	TSTB	IFSW	;CURRENT ASSEMBLY STATUS (IF)
	BEQ	L585
	BITB	#1,OP3M
	BNE	L590
	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
	JMP	L565
L585:	MOV	PCX,EQUST	;PROGRAM COUNTER
	MOVB	#2,R1
	MOVB	ML27,R2
	JSR	PC,INSERT
L590:	JMP	L565

T15:	MOV	#CHAR2,R3	;SECONDARY STORE FOR INCOMING CHAR	* ()*/-+, *
	MOVB	(R3),R0
	CMPB	#'+,R0
	BEQ	1$
	CMPB	#'-,R0
	BNE	2$
1$:	TSTB	ML61
	BEQ	2$
	CMPB	#3,ML61
	BEQ	2$
	ADD	#3,R0
2$:	SUB	#46,R0
	MOVB	R0,(R3)
	JMP	L560
T16:	MOVB	#7,R1	;					* PROGRAM COUNTER $ *
	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN
	MOV	PCX,R1		;PROGRAM COUNTER
	JSR	PC,DSTCHR	;STORES ONE CHAR ON STACK - STK1D
	JMP	L600

T17:	MOVB	#5,R1	;READS TEXT BETWEEN QUOTES		* APOSTROPHE (TEXT) *
	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN
L620:	JSR	PC,READ	;READING SUBROUTINE
	SUB	#CR,R0
	BEQ	L605
	MOVB	(R3),R0
	SUB	#'',R0
	BNE	L610
	JSR	PC,READ	;READING SUBROUTINE
	SUB	#'',R0
	BNE	L615
L610:	MOVB	(R3),R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	BR	L620
L605:	MOVB	#'B,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L615:	DECB	CHRCT		;COUNT OF CHARS AVAILABLE
	JMP	L600

T18:	MOVB	#7,R1	;READS AND CONVERTS NUMBER TO HEX	* DIGITS *
	JSR	PC,RDSTR	;READS STRING OF CHARS
	MOV	#STK1D,R3	;STACK FOUR
	DECB	(R3)
	MOVB	(R3),R3
	DECB	(R3)
	MOV	STK1A,R4
	ADD	R4,R3
	MOVB	(R3),R0	;GET DATA
	MOV	#16.,R5
	CMP	#'H,R0
	BEQ	1$
	ASR	R5
	CMP	#'O,R0
	BEQ	1$
	CMP	#'Q,R0
	BEQ	1$
	MOVB	#2,R5
	CMP	#'B,R0
	BEQ	1$
	MOVB	#10.,R5
	CMP	#'D,R0
	BEQ	1$
	INCB	STK1D		;STACK FOUR
1$:	CLR	R2		;FIRST OPERAND
	BR	L696
L695:	JSR	PC,MULT		;MULTIPLICATION
L696:	MOVB	(R4)+,R1
	SUB	#'0,R1
	CMPB	#9.,R1
	BCC	2$
	SUB	#7,R1		;DE-ASCII NUMBER
2$:	CMPB	R1,R5
	BCS	L670		;JUMP IF NUMBER LESS THAN BASE
	MOVB	#'I,R1		;ERROR IF NUMBER GREATER THAN BASE
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	CLR	R1		;SECONDARY STORE FOR INCOMING CHAR
L670:	ADD	R2,R1
	MOV	R5,R2
	DECB	STK1D
	BNE	L695
	JSR	PC,DSTCHR	;STORES ONE CHAR ON STACK - STK1D
	JMP	L600

MULT:	CMP	R1,R2	;MULTIPLICATION
	BPL	L680
	MOV	R1,R3
	MOV	R2,R1
	MOV	R3,R2
L680:	MOV	R2,R3
	CLR	R2
L690:	ROR	R1
	BCC	L685
	ADD	R3,R2
L685:	ASL	R3
	TST	R1
	BNE	L690
	RTS	PC

MULERR:	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#'A,R1
	JSR	PC,ERROR
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	RTS	PC

T19:	MOV	SYMB2,R3	;					* LETTERS *
	DEC	R3
	MOV	R3,OP2	;SECOND OPERAND
	CLR	R1
	JSR	PC,RDSTR	;READS STRING OF CHARS
	MOV	#STK1D,R3	;STACK FOUR
	CMPB	#5,(R3)
	BCC	L700
	MOVB	#5,(R3)
L700:	MOVB	#1,R1
	JSR	PC,FIND
	TSTB	R0
	BNE	L705
	CLR	R1
	JSR	PC,FIND
	DECB	R0
	BNE	L705
	MOV	OP2,R1
	MOV	R1,TSTR2
	ADD	#2,R1
	MOV	R1,SYMB2
	JSR	PC,S30
	BIS	#128.,R1
	MOV	TSTR2,R3	;HOLDS ADDRESS OF COMPILED CODE
	MOVB	R1,(R3)+
	MOVB	CHAR2,(R3)
	MOVB	#1,OP3M
L705:	CMPB	#23.,STK1C	;STACK THREE
	BNE	L710
	MOV	OP2,MD31	;SECOND OPERAND
L710:	TSTB	STK1C		;STACK THREE
	BNE	L715
	CMPB	#1,ML99
	BCC	L715
	MOVB	#2,R1
	JSR	PC,FIND
	CMPB	#' ,R0
	BEQ	L715
	CLR	R1
	JSR	PC,FIND
	MOVB	R0,STK1C	;STACK THREE
L715:	MOVB	STK1C,CHAR2	;STACK THREE
	CMPB	CHAR2,#31.
	BCS	L720
	MOVB	#2,STK1C	;STACK THREE
L720:	CMPB	#10.,STK1C
	BCC	L721
	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
L721:	CMPB	#4,CHAR2
	BCS	L561
	JMP	L600
L561:	JMP	L560

L555:	ASL	R3
	ADD	PC,R3
	ADD	#JTAB1-.,R3
	ADD	(R3),PC

JTAB1:	.WORD	T10-JTAB1	;ILLEGAL CHARACTERS
	.WORD	T11-JTAB1	;SPACE AND TAB
	.WORD	T12-JTAB1	;COMMENTS
	.WORD	T13-JTAB1	;LABELS
	.WORD	T14-JTAB1	;CARRIAGE RETURN
	.WORD	T15-JTAB1	; ()*+/-,
	.WORD	T16-JTAB1	;PROGRAM COUNTER ($)
	.WORD	T17-JTAB1	;TEXT (BETWEEN QUOTES)
	.WORD	T18-JTAB1	;DIGITS
	.WORD	T19-JTAB1	;LETTERS
	.WORD	T9-JTAB1	;FORM FEED

TAB3:	.BYTE	0		;LIST & PUNCH
	.BYTE	128.		;
	.BYTE	0		;PSW
	.BYTE	0		;BALANCE ERROR
	.BYTE	15.		;MULTIPLY
	.BYTE	15.		;ADDS
	.BYTE	0		;F ERROR
	.BYTE	15.		;SUBTRACT
	.BYTE	13.		;LIST & PUNCH
	.BYTE	15.		;DIVIDE
	.BYTE	13.		;NEGATE
;	.BYTE	13.		;NOT
	.BYTE	13.		;LOW
	.BYTE	15.		;AND
	.BYTE	15.		;OR
	.BYTE	15.		;XOR
	.BYTE	15.		;MOD
	.BYTE	15.		;ROTATE LEFT
	.BYTE	15.		;ROTATE RIGHT
	.BYTE	64.		;DEFINE BYTE
	.BYTE	1		;DEFINE STORE
	.BYTE	77.		;DEFINE WORD
	.BYTE	128.		;END
	.BYTE	128.		;ENDIF
	.BYTE	128.		;ENDM
	.BYTE	1		;EQU
	.BYTE	129.		;IF
	.BYTE	128.
	.BYTE	64.		;MACRO
	.BYTE	64.
	.BYTE	1		;ORG
	.BYTE	1		;SET
	.BYTE	64.		;TITLE
	.BYTE	64.
	.BYTE	64.
	.BYTE	71.		;LXI
	.BYTE	7		;INX
	.BYTE	7		;LDAX
	.BYTE	7		;SUB
	.BYTE	23.		;SBI
	.BYTE	71.		;MVI
	.BYTE	7		;RST
	.BYTE	71.		;MOV
	.BYTE	55.		;LDA
	.BYTE	5		;XTHL
	.BYTE	13.		;LOW
	.EVEN
L560:	MOVB	CHAR2,R0	;SECONDARY STORE FOR INCOMING CHAR
	ADD	#TAB3,R0
	CMPB	(R0),#128.
;	BCC	1$
;	BITB	#1,IFSW
;	BEQ	1$
	MOVB	#0,R0
	SBCB	R0
	MOV	#IFSW,R3
	COMB	(R3)
	BICB	(R3),R0
	COMB	(R3)
	RORB	R0
	BCC	1$
	JMP	L565
1$:	MOVB	CHAR2,R1	;SECONDARY STORE FOR INCOMING CHAR
	MOVB	R1,ML61
	JSR	PC,TABLK	;LOOKS UP <C> IN ITS TABLE
	MOV	#ML67,R3
	MOVB	(R3)+,R2
	ADD	R2,R3
	MOV	R0,-(SP)
	MOVB	(R3),R1
	MOVB	R1,MD27
	JSR	PC,TABLK	;LOOKS UP <C> IN ITS TABLE
	MOV	(SP)+,R2
	CMPB	R0,R2
	BCS	2$
	MOV	#ML61,R3
	CMPB	#2,(R3)+
	BNE	L725
2$:	MOV	#ML67,R3
	INCB	(R3)
	MOVB	(R3)+,R1
	ADD	R1,R3
	MOVB	ML61,(R3)
	JMP	L565
L725:	TSTB	(R3)
	BNE	L730
	DEC	R3
	MOVB	(R3)+,(R3)
	BR	L735
L730:	DECB	ML67
L735:	MOVB	MD27,R0
	ADD	#TAB3,R0
	MOVB	(R0),OP4M
	BITB	#1,(R0)
	BEQ	L740
	JSR	PC,S30
	MOV	R1,(R3)
L740:	MOV	#OP4M,R3
	MOVB	(R3),R0
	ASRB	R0
	BCC	L741
	BIS	#200,R0
L741:	MOVB	R0,(R3)
	RORB	R0
	BCC	L745
	JSR	PC,S30
	MOV	R1,-(R3)
L745:	MOVB	#7,ML26
	MOVB	MD27,R3
	BIC	#177400,R3
	JMP	L750
T21:	MOVB	STK1D,R3	;LISTING AND PUNCHING ;STACK FOUR
	ADD	STK1A,R3	;STACK ONE
	MOV	R3,TSTR1	;ADDRESS OF END OF COMPILED CODE
	TSTB	IFSW		;CURRENT ASSEMBLY STATUS (IF)
	BEQ	L755
	MOV	#TBUFF,TSTR1	;BUFFER FOR INCOMING PSEUDO INSTRUCTIONS
L755:	TSTB	DISP		;DISPLACEMENT ON STACKS
	BEQ	L760
	CMPB	STK1C,#6
	BEQ	L765
	MOVB	#'Q,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L765:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
	BR	L755
L760:	MOV	#TBUFF,TSTR2	;BUFFER FOR INCOMING PSEUDO INSTRUCTIONS
	MOVB	#1,ML27
	BITB	#1,PASS
	BNE	L770		;JUMP IF NOT PASS 2 OR 4
L815:	BITB	#1,ML27
	BEQ	L770
	MOVB	#CR,R1
	JSR	PC,LIST	;LISTING ROUTINE
	MOVB	ERRLT,R1	;CODE LETTER FOR ERROR
	JSR	PC,LIST	;LISTING ROUTINE
	MOVB	#' ,R1
	JSR	PC,LIST	;LISTING ROUTINE
	MOV	TSTR2,R0
	SUB	TSTR1,R0	;ADDRESS OF END OF COMPILED CODE
	ADD	#-1,R0
	MOVB	#0,R0
	SBCB	R0
	MOV	#ML69,R3
	BISB	(R3),R0
	MOVB	R0,(R3)
	RORB	R0
	BCC	L775		;JUMPS IF <MD22> = <MD21> AND ML69 =0
	MOVB	LSTPC+1,R1	;PROGRAM COUNTER
	JSR	PC,LISTA	;LISTS <C>
	MOVB	LSTPC,R1	;PROGRAM COUNTER
	JSR	PC,LISTA	;LISTS <C>
L775:	MOV	#ML69,R3
	MOVB	(R3),R0
	COMB	R0
	BIC	#-2,R0
	ASLB	R0
	ASLB	R0
	MOVB	R0,(R3)
	CLRB	ML70
L785:	CMPB	ML69,ML70
	BCS	L780
	MOVB	#' ,R1
	JSR	PC,LIST	;LISTING ROUTINE
	INCB	ML70
	BNE	L785
L780:	MOVB	#1,ML70
L805:	CMPB	#4,ML70
	BCS	L790
	CMP	TSTR2,TSTR1
	BCC	L795
	MOVB	@TSTR2,R1	;HOLDS ADDRESS OF COMPILED CODE
	JSR	PC,LISTA	;LISTS <C>
	BR	L800
L795:	MOVB	#' ,R1
	JSR	PC,LIST	;LISTING ROUTINE
	MOVB	#' ,R1
	JSR	PC,LIST	;LISTING ROUTINE
L800:	MOV	#ML27,R3
	CLRB	(R3)
	INC	TSTR2		;HOLDS ADDRESS OF COMPILED CODE
	CMP	TSTR2,TSTR1
	SBCB	(R3)+
	INCB	(R3)
	BNE	L805
L790:	MOVB	#' ,R1
	JSR	PC,LIST	;LISTING ROUTINE
	MOVB	#LF,R1
	JSR	PC,LIST	;LISTING ROUTINE
	ADD	#4,LSTPC	;PROGRAM COUNTER
	CLRB	PNCST		;CLEARED TO INDICATE REPEAT LINE
	BR	L815
L770:	CMPB	#2,PASS
	BCC	L820
	MOV	#TBUFF,TSTR2	;BUFFER FOR INCOMING PSEUDO INSTRUCTIONS
	MOVB	RCLEN,R0	;LENGTH OF PUNCHED RECORD
	ADD	RCADR,R0	;LOADING ADDRESS OF PUNCHED RECORD
	SUB	PCX,R0		;PROGRAM COUNTER
	ADD	#-1,R0
	MOVB	#0,R0
	SBCB	R0
	BISB	EXIT,R0		;SET WHEN ASSEMBLY COMPLETED
	RORB	R0
	BCC	L825
	TSTB	RCLEN		;LENGTH OF PUNCHED RECORD
	BEQ	L830
	CLR	R1
	JSR	PC,PRCRD	;PUNCHES RECORD
L830:	MOV	PCX,RCADR		;PROGRAM COUNTER
L825:	CMP	TSTR2,TSTR1
	BCC	L835
	MOV	#RCLEN,R3	;LENGTH OF PUNCHED RECORD
	CMPB	(R3),-(R3)
	BNE	L840
	CLR	R1
	JSR	PC,PRCRD	;PUNCHES RECORD
	ADD	#16.,RCADR	;LOADING ADDRESS OF PUNCHED RECORD
L840:	MOV	#RCLEN,R3	;LENGTH OF PUNCHED RECORD
	INCB	(R3)
	MOVB	(R3),R2
	ADD	#RCDAT,R2	;DATA AREA FOR DATA FOR PUNCHING
	MOV	TSTR2,R3	;HOLDS ADDRESS OF COMPILED CODE
	MOVB	(R3),R1
	MOVB	R1,(R2)
	MOV	#RCSUM,R3	;SUM OF CHARACTERS IN PUNCHED RECORD
	MOVB	(R3),R0
	SUB	R1,R0
	MOVB	R0,(R3)
	INC	TSTR2		;HOLDS ADDRESS OF COMPILED CODE
	BR	L825
L835:	TSTB	EXIT		;SET WHEN ASSEMBLY COMPLETED
	BEQ	L820
	MOVB	#1,R1
	JSR	PC,PRCRD	;PUNCHES RECORD
L820:	MOV	PCX,R3		;PROGRAM COUNTER
	ADD	TSTR1,R3	;ADDRESS OF END OF COMPILED CODE
	SUB	#TBUFF,R3	;BUFFER FOR INCOMING PSEUDO INSTRUCTIONS
	MOV	R3,LSTPC	;PROGRAM COUNTER
	MOV	R3,PCX		;PROGRAM COUNTER
	CLRB	ML69
	CLRB	OP3M
	CLRB	OP3M+1
	INCB	PNCST	;CLEARED FOR REPEAT LINES OF CODE
	MOVB	#' ,ERRLT	;CODE LETTER FOR ERROR
	CLRB	ML67
	CLR	R0
	MOV	#IFSW,R3	;CURRENT ASSEMBLY STATUS (IF)
	CMPB	R0,(R3)
	MOVB	#0,R0
	SBCB	R0
	MOVB	R0,(R3)
	TSTB	EXIT		;SET WHEN ASSEMBLY COMPLETED
	BEQ	L854
	RTS	PC
L854:	JMP	L565
				;OPEN BRACKET
T22:	MOV	#MD27,R3	;CLOSE BRACKET
	CMPB	#2,(R3)
	BNE	1$
	CMPB	#3,-(R3)
	BEQ	L855
1$:	MOVB	#'B,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L855:	CMPB	#6,STK1C	;STACK THREE
	BNE	L860
	MOVB	#1,STK1D	;STACK FOUR
L860:	CMPB	#3,ML61
	BNE	L861
	JMP	L565

T24:	MOV	OP2,R2	;MULTIPLIES
	MOV	OP1,R1	;FIRST OPERAND
	JSR	PC,MULT	;MULTIPLICATION
	MOV	R2,OP1	;FIRST OPERAND
L861:	JMP	T20

T25:	ADD	OP2,OP1	;ADDS
	JMP	T20

T26:	MOVB	#'F,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	JMP	T20

T27:	SUB	OP2,OP1
	JMP	T20

T28:	MOV	OP2,R2	;DIVIDE	;SECOND OPERAND
	MOV	OP1,R1	;FIRST OPERAND
	JSR	PC,DIVID	;DIVISION
	MOV	R1,OP1	;FIRST OPERAND
	JMP	T20

DIVID:	NEG	R2	;DIVISION
	CLR	R3
	MOV	#17.,R0
L875:	MOV	R3,R4
	ADD	R2,R3
	BCS	L870
	MOV	R4,R3
L870:	ROL	R1
	ROL	R3
	DECB	R0
	BNE	L875
	ASR	R3
	MOV	R3,R2
	RTS	PC

T29:	NEG	OP1	;FIRST OPERAND
	JMP	T20

T30:	CMPB	#XXX,STK1B
	BEQ	AA
	COM	OP1	;NOT	;FIRST OPERAND
	JMP	T20
AA:	CLRB	OP1M
	JMP	T20

T31:	MOV	OP2,R3	;AND	;FIRST OPERAND
	COM	R3
	BIC	R3,OP1
	JMP	T20

T32:	BIS	OP2,OP1	;OR	;FIRST OPERAND
	JMP	T20

T33:	MOV	OP2,R0	;EXCLUSIVE OR	;FIRST OPERAND
	BIC	OP1,R0
	BIC	OP2,OP1
	BIS	R0,OP1
	JMP	T20

T34:	MOV	OP2,R2	;MOD	;SECOND OPERAND
	MOV	OP1,R1	;FIRST OPERAND
	JSR	PC,DIVID	;DIVISION
	MOV	R2,OP1	;FIRST OPERAND
	JMP	T20

T35:			;ROTATE LEFT	;SECOND OPERAND
	MOV	OP2,R0
	BEQ	L881
L880:	ASL	OP1
	DECB	R0
	BNE	L880
L881:	JMP	T20

T36:			;ROTATE RIGHT	;SECOND OPERAND
	MOV	OP2,R0
	BEQ	L881
L885:	ASR	OP1
	DECB	R0
	BNE	L885
	JMP	T20

T37:	MOV	#STK1C,R3	;DEFINE BYTE	;STACK THREE
	CMPB	#5,(R3)
	BEQ	L886
	CMPB	#6,(R3)
	BEQ	L886
	JSR	PC,S30
	MOV	R1,-(R3)
	INC	R3
	MOVB	(R3),R0
	DECB	R0
	CMPB	R0,#-2
	BCC	L887
	MOVB	#'V,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L887:	MOVB	#34.,OP4M
L886:	MOVB	#6,STK1C	;STACK THREE
	MOVB	#6,ML26
	JMP	T20

T38:	MOVB	#1,ML69
	ADD	OP2,PCX
	JMP	L560

T39:	MOVB	#6,ML26	;DEFINE WORD
	JMP	T20

T40:	CLR	PCX		;END	;PROGRAM COUNTER
	CLR	OP1		;FIRST OPERAND
	TSTB	DISP		;DISPLACEMENT ON STACKS
	BEQ	L888
	JSR	PC,S30
	MOV	R1,PCX		;PROGRAM COUNTER
L888:	MOVB	#1,ML69
	MOVB	#1,EXIT		;SET WHEN ASSEMBLY COMPLETED
	CLRB	IFSW		;CURRENT ASSEMBLY STATUS (IF)
	MOV	TOPAD,SYMB3	;INCREASING WORK SPACE
	JMP	T20

T41:	CLR	R1	;ENDIF
	JSR	PC,IFCM	;DEALS WITH IF COMMAND ?
	JMP	T20

T42:	
	MOV	#STK2A,R3	;ENDM	;SECOND STACK - A
	MOVB	(R3),R0
	SUB	#1,R0
	MOVB	#0,R0
	SBCB	R0
	MOV	#IFSW,R3	;CURRENT ASSEMBLY STATUS (IF)
	COMB	(R3)
	BICB	(R3),R0
	COMB	(R3)
	COMB	R0
	RORB	R0
	BCS	L891
;	TSTB	STK2A	;ENDM	;SECOND STACK - A
;	BNE	L891
;	BITB	#1,IFSW
;	BNE	L891
	JMP	T20
L891:	MOV	#-1,R0
	CMPB	#1,PASS
	BEQ	L889
	CLR	R0
L889:	MOV	#MCRSW,R3	;READING MACROS SWITCH
	COMB	(R3)
	BICB	(R3),R0
	COMB	(R3)
	RORB	R0
	BCC	L890
;	CMPB	#1,PASS
;	BNE	L890
;	BITB	#1,MCRSW
;	BNE	L890
	MOVB	#MCEND,@MD31	;MACRO TERMINATION IN MEMORY CHARACTER
	MOV	BOTAD,R1	;DECREASING WORK SPACE
	MOV	MD31,R2
	JSR	PC,MOVEM	;MOVES DATA INTO MEMORY FOR MACROS?
	MOV	R1,SYMB3
	MOV	R1,@MD32
L890:	MOVB	#3,R1
	JSR	PC,IFCM	;DEALS WITH IF COMMAND ?
	JMP	T20

T43:	MOV	OP1,EQUST	;EQU	;FIRST OPERAND
	MOVB	#2,R1
	CLRB	R2
	JSR	PC,INSERT
	MOVB	#1,ML69
	JMP	T20

T44:	CLR	R1	;IF
	JSR	PC,EIFCM	;DEALS WITH ENDIF COMMAND ?
	CMPB	#1,IFCNT
	MOVB	#0,R1
	SBCB	R1
	MOV	#OP1,R3	;FIRST OPERAND
	MOV	(R3),R0
	SUB	#1,R0
	MOVB	#0,R0
	SBCB	R0
	BIC	#-2,R0
	MOV	#IFSW,R3	;CURRENT ASSEMBLY STATUS (IF)
	BISB	(R3),R0
	COMB	R1
	BICB	R1,R0
	MOVB	R0,(R3)
	JMP	T20

T45:	MOVB	#1,R1	;NO IDEA
	JSR	PC,IFCM	;DEALS WITH IF COMMAND ?
	JMP	T21

T46:	MOV	STK1B,R3	;MACRO    STACK TWO
	ADD	#6,R3
	MOV	R3,MD32
	CMPB	#1,PASS
	BNE	L892
	MOV	EOFM,EQUST	;CONTAINS ADDRESS OF END OF MEMORY
	MOVB	#' ,R1
	CLRB	R2
	JSR	PC,INSERT
	BR	L893
L892:	CMP	@MD32,EOFM
	BNE	L894
	MOVB	#'T,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L894:	CMPB	#3,STK1C	;STACK THREE
	BNE	L895
	MOVB	#'M,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L895:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
L893:	MOVB	#3,R1
	JSR	PC,EIFCM	;DEALS WITH ENDIF COMMAND ?
	MOVB	#28.,CHAR2	;SECONDARY STORE FOR INCOMING CHAR
	CLRB	MS16
	JMP	T20

T47:	TSTB	DISP		;NO IDEA	;DISPLACEMENT ON STACKS
	BEQ	L896
	CMPB	#1,PASS
	BNE	L897
	MOV	#MS16,R2
	INCB	(R2)
	MOV	#EQUST,R3	;EQUATE STORE
	MOVB	(R2),(R3)+
	CLRB	(R3)
	MOVB	#1,R1
	CLRB	R2
	JSR	PC,INSERT
	BR	L896
L897:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
L896:	CMPB	#1,ML61
	BEQ	1$
	JMP	T20
1$:	MOVB	#1,IFSW	;CURRENT ASSEMBLY STATUS (IF)
	MOV	BOTAD,SYMB2
	MOV	#ERRLT,R3	;CODE LETTER FOR ERROR
	MOVB	(R3),R0
	SUB	#' ,R0
	SUB	#1,R0
	MOVB	#0,R0
	SBCB	R0
	MOVB	R0,MCRSW	;READING MACROS SWITCH
	JMP	T20

T48:	MOVB	#1,ML69		;ORG
	MOV	OP1,PCX		;FIRST OPERAND
	JMP	T20

T49:	CLRB	ML27		;SET
	MOVB	STK1C,R1	;STACK THREE
	SUB	#1,R1
	MOVB	#0,R1
	SBCB	R1
	CMPB	#1,ML99
	MOVB	#0,R0
	SBCB	R0
	COMB	R1
	BICB	R1,R0
	RORB	R0
	BCC	L898
	MOVB	#2,ML27
	MOVB	#2,R1
	JSR	PC,FIND
	SUB	#4,R0
	ADD	#-1,R0
	MOVB	#0,R0
	SBCB	R0
	MOVB	STK1C,R1	;STACK THREE
	ADD	#-1,R1
	MOVB	#0,R1
	SBCB	R1
	COMB	R0
	BICB	R0,R1
	RORB	R1
	BCC	L899
	MOVB	#'M,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
L899:	CMPB	#4,STK1C	;STACK THREE
	BEQ	L898
	CLRB	ML27
	CLR	R1
	JSR	PC,FIND
	MOVB	R0,STK1C	;STACK THREE
L898:	MOV	OP1,EQUST	;FIRST OPERAND
	MOVB	#4,R1
	MOVB	ML27,R2
	JSR	PC,INSERT
	MOVB	#1,ML69
L901:	JMP	T20

T50:	TSTB	DISP
	BEQ	L901
	MOV	STK1A,R3
	MOV	#ETIT,R2
	MOVB	STK1D,R1
	MOV	#ETIT-TITL,TITCNT
	ADD	R1,TITCNT
TITLP:	MOVB	(R3)+,(R2)+
	DECB	R1
	BNE	TITLP
2$:	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
	TSTB	DISP		;TITLE
	BNE	2$
	JMP	T20

T51:	MOV	#ML61,R3	;NO IDEA
	CMPB	#27.,(R3)+
	BNE	2$
	JMP	T46
2$:	MOVB	#33.,(R3)
	MOV	TOPAD,MD32	;INCREASING WORK SPACE

T52:	CMPB	DISP,#2		;NO IDEA	;DISPLACEMENT ON STACKS
	BCC	L903
	MOVB	#5,R1
	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN
L903:	CMPB	STK1C,#5	;STACK THREE
	BEQ	L904
	JSR	PC,S30
	MOV	R1,TSTR2	;HOLDS ADDRESS OF COMPILED CODE
	MOVB	#5,R1
	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN
	MOVB	#'0,R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	OP1M,R1		;UPPER BYTE OF FIRST OPERAND
	ASRB	R1
	ASRB	R1
	ASRB	R1
	ASRB	R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	OP1M,R1		;UPPER BYTE OF FIRST OPERAND
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	OP1,R1		;FIRST OPERAND
	ASRB	R1
	ASRB	R1
	ASRB	R1
	ASRB	R1
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	OP1,R1		;FIRST OPERAND
	JSR	PC,HXTOA	;NIBBLE TO ASCII
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	#'H,R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
L904:	MOVB	STK1D,R1	;STACK FOUR
	MOVB	R1,ML27
	INCB	R1
	BISB	#128.,R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
	MOVB	ML27,R2
	MOV	STK1A,R1	;STACK ONE
	ADD	R1,R2		;STACK ONE
	JSR	PC,MOVEM	;MOVES DATA INTO MEMORY FOR MACROS?
	MOV	R1,OP2		;SECOND OPERAND
	JSR	PC,UNSTK	;MOVES DATA OFF STACKS
	CMPB	#1,ML61
	BNE	L906
	CMPB	#1,DISP		;DISPLACEMENT ON STACKS
	BEQ	L905
	MOVB	#'F,R1
	JSR	PC,ERROR	;ERROR HANDLING SUBROUTINE
	BR	L906
ML76:	.BYTE	128.
ML77:	.BYTE	129.
L905:	MOV	#ML76,R1
	MOV	#ML77,R2
	JSR	PC,MOVEM	;MOVES DATA INTO MEMORY FOR MACROS?
	MOV	R1,OP2		;SECOND OPERAND
	MOVB	#1,R1
	JSR	PC,EIFCM	;DEALS WITH ENDIF COMMAND ?
	JSR	PC,S30
	MOV	R1,SYMB2
	MOVB	#1,MACSW
	MOV	MD32,SYMB3
	CMPB	ERRLT,#'F	;CODE LETTER FOR ERROR
	BNE	L906
	JMP	T45

T53:	MOVB	#133.,R1	;LXI
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
L906:	JMP	T20

T54:	MOVB	#5,R1	;INX
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T55:	MOVB	#7,R1	;LDAX
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T56:	MOVB	#2,R1	;SUB
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T57:	MOVB	#08.,R1	;SUB
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T58:	MOVB	#70.,R1	;MVI
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T59:	MOVB	#6,R1	;RST
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T60:	MOVB	#54.,R1	;MOV
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T61:			;LDA
T62:	CLR	R1	;XTHL
	JSR	PC,INSDC	;CODES PSEUDO INSTRUCTIONS
	JMP	T20

T63:	CLRB	OP1M		;TRUNCATES 16 BITS TO 8
	JMP	T20

L750:	ASL	R3
	ADD	PC,R3
	ADD	#TAB4-.,R3
	ADD	(R3),PC
TAB4:	.WORD	T20-TAB4	;LISTING AND PUNCHING
	.WORD	T21-TAB4	;
	.WORD	T22-TAB4	;CONSTANTS LIKE PSW
	.WORD	T22-TAB4	;OPEN & CLOSE BRACKET
	.WORD	T24-TAB4	;MULTIPLIES
	.WORD	T25-TAB4	;ADDS
	.WORD	T26-TAB4	;F ERROR
	.WORD	T27-TAB4	;SUBTRACT
	.WORD	T20-TAB4	;LISTING AND PUNCHING
	.WORD	T28-TAB4	;DIVIDE
	.WORD	T29-TAB4	;NEGATE
	.WORD	T30-TAB4	;NOT
	.WORD	T31-TAB4	;AND
	.WORD	T32-TAB4	;OR
	.WORD	T33-TAB4	;EXCLUSIVE OR
	.WORD	T34-TAB4	;MOD
	.WORD	T35-TAB4	;ROTATE LEFT
	.WORD	T36-TAB4	;ROTATE RIGHT
	.WORD	T37-TAB4	;DEFINE BYTE
	.WORD	T38-TAB4	;DEFINE STORE
	.WORD	T39-TAB4	;DEFINE WORD
	.WORD	T40-TAB4	;END
	.WORD	T41-TAB4	;ENDIF
	.WORD	T42-TAB4	;ENDM
	.WORD	T43-TAB4	;EQU
	.WORD	T44-TAB4	;IF
	.WORD	T45-TAB4
	.WORD	T46-TAB4	;MACRO
	.WORD	T47-TAB4
	.WORD	T48-TAB4	;ORG
	.WORD	T49-TAB4	;SET
	.WORD	T50-TAB4	;TITLE
	.WORD	T51-TAB4
	.WORD	T52-TAB4
	.WORD	T53-TAB4	;LXI
	.WORD	T54-TAB4	;INX
	.WORD	T55-TAB4	;LDAX
	.WORD	T56-TAB4	;SUB
	.WORD	T57-TAB4	;SBI
	.WORD	T58-TAB4	;MVI
	.WORD	T59-TAB4	;RST
	.WORD	T60-TAB4	;MOV
	.WORD	T61-TAB4	;LDA
	.WORD	T62-TAB4	;XTHL
T20:	BITB	#1,ML69
	BEQ	L908
	MOV	OP1,LSTPC	;FIRST OPERAND
L908:	BITB	#31.,OP4M
	BEQ	L909
	MOVB	ML26,R1
	JSR	PC,STSTK	;DATA ON STACKS IS PUSHED DOWN
L909:	CLRB	ML27
L912:	CMPB	#3,ML27
	BCS	L910
	MOV	#OP4M,R3
	MOVB	(R3),R0
	ASRB	R0
	BCC	1$
	BIS	#200,R0
1$:	MOVB	R0,(R3)
	RORB	R0
	BCC	L911
	MOVB	ML27,R3
	ADD	#OP1,R3	;FIRST OPERAND
	MOVB	(R3),R1
	JSR	PC,STCHR	;STORES ONE CHAR ON STACK - STK1D
L911:	INCB	ML27
	BNE	L912
L910:	BITB	#2,OP4M
	BEQ	L913
	MOV	#ML61,R3
	CMPB	(R3)+,#6
	BNE	L913
	MOVB	(R3),CHAR2
L913:	JMP	L560
OP1:	.BLKB	1	;FIRST OPERAND
OP1M:	.BLKB	1	;UPPER BYTE OF FIRST OPERAND
OP2:	.BLKB	1	;SECOND OPERAND
OP2M:	.BLKB	1
OP3:	.BLKB	1
OP3M:	.BLKB	1
OP4:	.BLKB	1
OP4M:	.BLKB	1
IFCNT:	.BLKB	1	;COUNT OF NUMBER OF IF COMMANDS
STK2A:	.BLKB	8.	;SECOND STACK - A
IFSW:	.BLKB	8.	;CURRENT ASSEMBLY STATUS (IF)
ML99:	.BLKB	1
MACSW:	.BLKB	1		;SWITCH SET WHEN EXPANDING MACROS
MS14:	.BLKB	1
SYMB1:	.BLKW	5
SYMB2:	.BLKW	5
SYMB3:	.BLKW	5
SYMB4:	.BLKW	5	;CONTAINS END OF PROGRAM ADDRESS
SYMB5:	.BLKW	5
SYMBX:	.BLKW	1	;END OF SYMBOL TABLE
MCRSW:	.BLKB	1	;READING MACROS SWITCH
MS16:	.BLKB	1
MD32:	.BLKW	1
MD31:	.BLKW	1
EOFM:	.BLKW	1	;CONTAINS ADDRESS OF END OF MEMORY
TOPAD:	.BLKW	1	;INCREASING WORK SPACE
BOTAD:	.BLKW	1	;DECREASING WORK SPACE
PASS:	.BLKB	1		;PASS NUMBER
RCMAX:	.BLKB	1	;MAXIMUM PUNCHED RECORD LENGTH
RCLEN:	.BLKB	1	;LENGTH OF PUNCHED RECORD
RCSUM:	.BLKB	1	;SUM OF CHARACTERS IN PUNCHED RECORD
EXIT:	.BLKB	1	;SET WHEN ASSEMBLY COMPLETED
RCDAT:	.BLKB	17.	;DATA AREA FOR DATA FOR PUNCHING
RCADR:	.BLKW	1	;LOADING ADDRESS OF PUNCHED RECORD
TSTR1:	.BLKW	1	;ADDRESS OF END OF COMPILED CODE
TSTR2:	.BLKW	1	;HOLDS ADDRESS OF COMPILED CODE
TSTR3:	.BLKW	1
TSTR4:	.BLKW	1
ML27:	.BLKB	1
ML70:	.BLKB	1
ML67:	.BLKB	8.
PCX:	.BLKW	1	;PROGRAM COUNTER
LSTPC:	.BLKW	1	;PROGRAM COUNTER FOR LISTING
ML61:	.BLKB	1
MD27:	.BLKB	1
ML26:	.BLKB	1
CHAR2:	.BLKB	1	;SECONDARY STORE FOR INCOMING CHAR
CHRIN:	.BLKB	1	;INCOMING CHARACTER
ML63:	.BLKB	2
ML69:	.BLKB	1
CHCNT:	.BLKB	1	;COUNT OF CHARACTERS ON A LINE
CHRCT:	.BLKB	1	;COUNT OF CHARS AVAILABLE
ERRLT:	.BLKB	1	;CODE LETTER FOR ERROR
DISP:	.BLKB	1	;DISPLACEMENT ON STACKS
STK1A:	.BLKW	8.	;STACK ONE
STK1B:	.BLKW	8.	;STACK TWO
STK1C:	.BLKB	8.	;STACK THREE
STK1D:	.BLKB	8.	;STACK FOUR
MD24:	.BLKW	1
	.BLKB	1
LSTST:	.BLKB	1	;NO OF CHARS STORED IN LIST BUFFER
	.BLKB	1	;SWITCH FOR BEGIN/END OF LINE
	.BLKB	1	;ACTUAL CHARS ON LINE
	.BLKB	3	;ADDRESS IN LIST BUFFER +1 SPARE STORE
ERRST:	.BLKB	1	;STORAGE FOR ERROR ROUTINE
LUKS1:	.BLKB	3	;STORAGE FOR LUKUP ROUTINE
LUKS2:	.BLKB	1	;STORAGE FOR LUKUP ROUTINE 2
ML17:	.BLKB	1
HXST:	.BLKB	1	;STORAGE FOR NIBBLE TO ASCII ROUTINE
PNCST:	.BLKB	1	;STORAGE FOR PUNCH ROUTINE
LSTAS:	.BLKB	1	;STORAGE FOR LISTA ROUTINE
RCTYP:	.BLKB	1	;PUNCHED RECORD TYPE
ML23:	.BLKB	1
IDCST:	.BLKB	1	;STORAGE FOR	S37 ROUTINE	;
S17ST:	.BLKB	1	;STORE FOR <S17>
ML33:	.BLKW	1
ML39:	.BLKW	1
ML39A:	.BLKB	3
STKST:	.BLKB	1	;STORE FOR <STSTK>
CHRST:	.BLKB	1	;STORE FOR <STCHR>
RDST:	.BLKB	1	;STORE FOR <RDSTR>
ML46:	.BLKW	1
ML48:	.BLKB	1
ML49:	.BLKB	1
EQUST:	.BLKW	1	;EQUATE STORE
ML51:	.BLKB	1
ML53:	.BLKB	1
ML54:	.BLKB	1
TBUFF:	.BLKB	51.	;BUFFER FOR INCOMING PSEUDO INSTRUCTIONS
TAB5:	.ASCII	/A    /<3.><7.><0>
	.ASCII	/ACI  /<38.><206.><0>
	.ASCII	/ADC  /<37.><136.><0>
	.ASCII	/ADD  /<37.><128.><0>
	.ASCII	/ADI  /<38.><198.><0>
	.ASCII	/ANA  /<37.><160.><0>
	.ASCII	/AND  /<12.><0.><0>
	.ASCII	/ANI  /<38.><230.><0>
	.ASCII	/B    /<3.><0.><0>
	.ASCII	/C    /<3.><1.><0>
	.ASCII	/CALL /<42.><205.><0>
	.ASCII	/CC   /<42.><220.><0>
	.ASCII	/CM   /<42.><252.><0>
	.ASCII	/CMA  /<43.><47.><0>
	.ASCII	/CMC  /<43.><63.><0>
	.ASCII	/CMP  /<37.><184.><0>
	.ASCII	/CNC  /<42.><212.><0>
	.ASCII	/CNZ  /<42.><196.><0>
	.ASCII	/CP   /<42.><244.><0>
	.ASCII	/CPE  /<42.><236.><0>
	.ASCII	/CPI  /<38.><254.><0>
	.ASCII	/CPO  /<42.><228.><0>
	.ASCII	/CZ   /<42.><204.><0>
	.ASCII	/D    /<3.><2.><0>
	.ASCII	/DAA  /<43.><39.><0>
	.ASCII	/DAD  /<35.><9.><0>
	.ASCII	/DB   /<18.><0.><0>
	.ASCII	/DCR  /<40.><5.><0>
	.ASCII	/DCX  /<35.><11.><0>
	.ASCII	/DI   /<43.><243.><0>
	.ASCII	/DS   /<19.><0.><0>
	.ASCII	/DW   /<20.><0.><0>
	.ASCII	/E    /<3.><3.><0>
	.ASCII	/EI   /<43.><251.><0>
	.ASCII	/END  /<21.><0.><0>
	.ASCII	/ENDIF/<22.><0.><0>
	.ASCII	/ENDM /<23.><0.><0>
	.ASCII	/EQU  /<24.><0.><0>
	.ASCII	/H    /<3.><4.><0>
	.ASCII	/HLT  /<43.><118.><0>
	.ASCII	/IF   /<25.><0.><0>
	.ASCII	/IN   /<38.><219.><0>
	.ASCII	/INR  /<40.><4.><0>
	.ASCII	/INX  /<35.><3.><0>
	.ASCII	/JC   /<42.><218.><0>
	.ASCII	/JM   /<42.><250.><0>
	.ASCII	/JMP  /<42.><195.><0>
	.ASCII	/JNC  /<42.><210.><0>
	.ASCII	/JNZ  /<42.><194.><0>
	.ASCII	/JP   /<42.><242.><0>
	.ASCII	/JPE  /<42.><234.><0>
	.ASCII	/JPO  /<42.><226.><0>
	.ASCII	/JZ   /<42.><202.><0>
	.ASCII	/L    /<3.><5.><0>
	.ASCII	/LDA  /<42.><58.><0>
	.ASCII	/LDAX /<36.><10.><0>
	.ASCII	/LHLD /<42.><42.><0>
	.ASCII	/LOW  /<11.><123><321>
	.ASCII	/LXI  /<34.><1.><0>
	.ASCII	/M    /<3.><6.><0>
	.ASCII	/MACRO/<27.><0.><0>
	.ASCII	/MOD  /<15.><0.><0>
	.ASCII	/MOV  /<41.><64.><0>
	.ASCII	/MVI  /<39.><6.><0>
	.ASCII	/NOP  /<43.><0.><0>
XXX:	.ASCII	/NOT  /<11.><0.><0>
	.ASCII	/OR   /<13.><0.><0>
	.ASCII	/ORA  /<37.><176.><0>
	.ASCII	/ORG  /<29.><0.><0>
	.ASCII	/ORI  /<38.><246.><0>
	.ASCII	/OUT  /<38.><211.><0>
	.ASCII	/PCHL /<43.><233.><0>
	.ASCII	/POP  /<35.><193.><0>
	.ASCII	/PSW  /<3.><6.><0>
	.ASCII	/PUSH /<35.><197.><0>
	.ASCII	/RAL  /<43.><23.><0>
	.ASCII	/RAR  /<43.><31.><0>
	.ASCII	/RC   /<43.><216.><0>
	.ASCII	/RET  /<43.><201.><0>
	.ASCII	/RIM  /<43.><32.><0>
	.ASCII	/RLC  /<43.><7.><0>
	.ASCII	/RM   /<43.><248.><0>
	.ASCII	/RNC  /<43.><208.><0>
	.ASCII	/RNZ  /<43.><192.><0>
	.ASCII	/RP   /<43.><240.><0>
	.ASCII	/RPE  /<43.><232.><0>
	.ASCII	/RPO  /<43.><224.><0>
	.ASCII	/RRC  /<43.><15.><0>
	.ASCII	/RST  /<40.><199.><0>
	.ASCII	/RZ   /<43.><200.><0>
	.ASCII	/SBB  /<37.><152.><0>
	.ASCII	/SBI  /<38.><222.><0>
	.ASCII	/SET  /<30.><0.><0>
	.ASCII	/SHL  /<16.><0.><0>
	.ASCII	/SHLD /<42.><34.><0>
	.ASCII	/SHR  /<17.><0.><0>
	.ASCII	/SIM  /<43.><48.><0>
	.ASCII	/SP   /<3.><6.><0>
	.ASCII	/SPHL /<43.><249.><0>
	.ASCII	/STA  /<42.><50.><0>
	.ASCII	/STAX /<36.><2.><0>
	.ASCII	/STC  /<43.><55.><0>
	.ASCII	/SUB  /<37.><144.><0>
	.ASCII	/SUI  /<38.><214.><0>
	.ASCII	/TITLE/<31.><0.><0>
	.ASCII	/XCHG /<43.><235.><0>
	.ASCII	/XOR  /<14.><0.><0>
	.ASCII	/XRA  /<37.><168.><0>
	.ASCII	/XRI  /<38.><238.><0>
	.ASCII	/XTHL /<43.><227.><0>

	.WORD	0
FREE:	.WORD	0
DEVS:	.WORD	0
	.END	START