;
;
; TSTCH - TST00, TEST ALPHABETIC VS NUMERIC IN R2
;	REGISTERS USED - R2
TST00:	CMP	R2,#'0		;CHECK NUMERIC
	BLT	TST03		;NON-NUMERIC
	CMP	R2,#'9		;CHECK ALPHA
	BGT	TST01		;NON-NUMERIC
	SEZ			;SET ZERO CODE IF NUMERIC
	RTS	PC
TST01:	CMP	R2,#'A		;ALPHABETIC?
	BLT	TST03		;NO
	CMP	R2,#'Z		;ALPHABETIC?
	BGT	TST03		;NO
	CCC			;SET NON-ZERO CODE IF ALPHABETIC
	RTS	PC
TST03:	CCC
	SEV			;SET
	RTS	PC		;OVERFLOW IF NEITHER
;
; PRINTC - PRNT00, TYPE ONE CHARACTER CONTAINED IN R2
;	REGISTERS USED - R2.
;
PRNT00:	MOV	R1,-(SP)	;SAVE R1
	MOV	#TTY0,R1	;DEFAULT IS TELETYPE
	TST	SAVF		;IS THIS A SAVE?
	BEQ	PRNT01		;NO
	MOV	SVLOC,R1	;YES, SET THE SAVE DEVICE
	BR	PRNT04
PRNT01:	INC	POSITN		;KEEP TRACK OF HOW MANY
	CMP	POSITN,#72.	;CHECK FOR A LONG LINE
	BLE	PRNT05		;EXIT IF LOTS OF ROOM
	MOV	R2,-(SP)	;SAVE R2
	MOV	R0,-(SP)	;BE NEAT
	CRLF
	MOV	(SP)+,R0	;RESTORE R0
	MOV	(SP)+,R2	;AND R2
PRNT05:	TST	ECHO		;IS THE ECHO OFF?
	BEQ	PRNT02		;YES, DON'T OUTPUT ANYTHING
PRNT04:	INC	RNDM		;INCREMENT THE RANDOMIZE FLAG
	TSTB	@R1		;WAIT READY
	BPL	PRNT04		; ON TTY0
	MOVB	R2,2(R1)	;OUTPUT THE CHARACTER
PRNT02:	MOV	(SP)+,R1	;RESTORE R1
PRN01:	RTS	PC
;
; ROUTINE TO TYPE <CR,LF>
;	REGISTER USED - R2.
;
CRLF00:	MOV	#-2,POSITN	;CLEAR THE POSITION TO ALLOW A FULL LINE
	MOV	#RDY01,R0	;GET ADDRESS OF <CR,LF>
;
; PRINTL - PRN00 - PRINT A LINE OF ASCII
;	R0 HAS STARTING ADDRESS, LINE IS TERMINATED BY A ZERO BYTE
;	REGISTERS USED - R0,R2.
PRN00:	MOVB	(R0)+,R2	;GET A CHARACTER
	BEQ	PRN01		;EXIT IF DONE
	PRINTC			;PRINT IT
	BR	PRN00		;LOOP
; PACK INPUT STRING INTO WORKING STORAGE
;	ADDRESS OF WORKING STORAGE RETURNED IN R1.  REGISTERS
;	USED - R1,R2,R3.
;
PCK05:	TST	OLDF		;IS THE OLD COMMAND IN PROCESS?
	BNE	PCK01		;YES, IGNORE ALL RUBOUTS
	CMP	#WORK,R3	;CHECK FOR EMPTY BUFFER
	BHIS	PCK00		;DON'T BACKSLASH IF EMPTY
	MOV	#'\,R2		;ECHO
	PRINTC			; BACKSLASH
	DEC	R3		;DELETE ONE CHARACTER
	BR	PCK01
PCK00:	MOV	#WORK,R3	;START OF WORKING STORAGE
PCK01:	TST	OLDF
	BEQ	PCK10
	CLR	ECHO		;TURN OFF ECHO FOR HSR
	MOV	DEVLOC,R2	;GET ADDRESS OF OLD DEVICE
	CMP	R2,#LSR		;IS DEVICE THE LSR?
	BNE	PCK14
	CLR	LSR		;TURN OFF INTERRUPTS IF SO
PCK14:	INCB	@R2		;ENABLE THE READER
PCK11:	INC	RNDM		;MAKE A RANDOM NUMBER
	TST	@R2		;CHECK FOR END OF TAPE OR ERROR
	BMI	PCK12		;ERROR
	TSTB	@R2		;WAIT UNTIL READY
	BPL	PCK11		;KEEP LOOPING
	MOV	2(R2),R2	;GET CHARACTER
	BEQ	PCK01		;IGNORE NULLS
	BIC	#177600,R2	;MASK OFF THE PARITY IF ANY
	CMPB	R2,#20		;IS THIS A ^P?
	BEQ	PCK03		;GO HANDLE IT IF IT IS
	CMPB	#15,R2		;CHECK FOR <CR>
	BNE	PCK06
	CRLF			;ECHO <CR,LF>
	MOV	#12,R2		;CONVERT TO <LF>
	BR	PCK04
PCK10:	CLR	KBD0		;TURN OFF KEYBOARD INTERRUPT
	MOV	#KBD0,R2	;SET DEVICE TO KEYBOARD
	BR	PCK11
PCK06:	CMPB	#177,R2		;RUBOUT?
	BEQ	PCK05		; IF SO, DON'T ECHO IT
	CMPB	#140,R2
	BLE	PCK09		;ERROR IF .GT. 140
	CMPB	#25,R2		;CHECK FOR ^U
	BEQ	PCK08
	PRINTC			;ECHO CHARACTER
PCK04:	MOVB	R2,(R3)+	;PACK ONE CHARACTER
	CMPB	R2,#12		;CHECK FOR LINE FEED
	BEQ	PCK02
	CMP	R3,#ENDW	;CHECK FOR STORAGE OVERFLOW
	BLO	PCK01		; OVERFLOW
	LINERR
PCK02:	MOV	#WORK,R1	;SET UP WORKING STORAGE POINTER
	MOV	#1,ECHO
	BIS	#100,KBD0	;TURN ON INPUT INTERRUPT
	RTS	PC
PCK08:	MOVB	#'^,R2		;^U IS PRINTED HERE
	PRINTC
	MOVB	#'U,R2		;NOW THE U
	PRINTC
	CRLF
	BR	PCK00		;DELETE CURRENT LINE
PCK03:	MOV	#100,KBD0
	CLR	-(SP)
	MOV	#INIT01,-(SP)
	MOV	R2,-(SP)
	BR	CTRL01
PCK09:	ILCERR			;ILLEGAL CHARACTER ON INPUT
PCK12:	CLR	OLDF
	MOV	#1,ECHO
	TST	(SP)+		;GET RID OF RETURN ADDRESS
	JMP	INIT00		;AND RETURN TO COMMAND MODE
;
; ^P	(CTRL P) HANDLER
;
CTRL00:	MOV	R2,-(SP)	;SAVE R2
	MOVB	KBD0+2,R2	;GET THE CHARACTER
	BIC	#177600,R2	;CLEAR OUT THE EXTRA BITS
	CMPB	R2,#20		;IS IT A ^P?
	BEQ	CTRL01		;YES
CTRL02:	MOV	(SP)+,R2	;NO
	RTI
CTRL01:	MOV	ECHO,-(SP)	;SAVE ECHO FLAG
	MOV	#1,ECHO		;THEN TURN IT ON
	MOV	#'^,R2		;TYPE ^
	PRINTC			; AND
	MOV	#'P,R2	;  P
	PRINTC
	MOV	(SP)+,ECHO	;RESTORE ECHO FLAG
	MOV	#1,CTRLP	;TELL BASIC THAT SOMETHING HAS HAPPENED
	BR	CTRL02		;THEN GO AWAY
;
; SKIP - SKIP00, SKIP OVER BLANKS IN WORKING STORAGE, R1 POINTS
;  TO LINE POSITION, CHARACTER FOUND GOES TO R2
;	REGISTERS USED - R1,R2.
;
SKIP00:	MOVB	(R1)+,R2	;GET A CHARACTER
	CMPB	#' ,R2		;IS IT BLANK?
	BEQ	SKIP00		;YES, GET ANOTHER
	RTS	PC
;
; JUNKIT - JUNK00, SKIP OVER REMAINDER OF LINE
;	UNTIL <LF> OR ":" IS FOUND.
;  R1 POINTS TO TERMINATOR ON EXIT.
;	REGISTERS USED - R1.
;
JUNK00:	CMPB	@R1,#':		;IS CHARACTER A ":"?
	BEQ	JUNK01		;JUMP IF YES
	CMPB	(R1)+,#12	;IS IT A <LF>?
	BNE	JUNK00		;NO, LOOK AGAIN
	DEC	R1		;YES, BACK UP POINTER ONE PLACE
JUNK01:	RTS	PC
;
; CLRUSR - CLRU00, CHECK FOR EXISTENCE OF USER SPACE, AND DELETE
;  IT IF PRESENT.  REGISTERS USED - R5.
;
CLRU00:	CLR	DATI		;CLEAR OUT DATA POINTER
	TST	ENDTXT		;IS THE USER SPACE SET UP?
	BEQ	CLRU01		;JUMP IF NOT
	MOV	ENDTXT,R5	;DELETE IT
	CLR	ENDTXT		;  IF IT IS.
CLRU01:	RTS	PC
;
; PSHNAM, PSH00 - PUSH A DUMMY VARIABLE ON THE USER LIST
;
PSH00:	PUSH			;PUT THE NAME ON THELIST
	CLR	R0		;CLEAR A CELL
	PUSH			;PUSH A ZERO DIMENSION
	MOV	R5,R0
	PUSH			;PUSH THREE MORE
	PUSH			;NOTHINGS ON
	PUSH			;THE USER LIST
	RTS	PC		; AND RETURN
;
; PUTAWY, PUT00 - PUSH A VALUE ON THE USER LIST
;
PUT00:	MOV	R2,R0		;PUT
	PUSH			; THE
	MOV	R3,R0		;  VALUE
	PUSH			;   AWAY
	MOV	R4,R0		;    PROPERLY
	PUSH
	RTS	PC		;AND RETURN
;
; PUSH - PUSH00, PUSH ONE WORD IN R0 ON USER STORAGE LIST
;	IF ENDTXT=0 ON ENTRY, SAVE R5 IN ENDTXT FIRST
;	IF R5 IS ODD, MOVE TO NEXT EVEN BOUNDARY
;	R5 IS UPDATED WHEN ITEM IS PLACED ON THE LIST
;	REGISTERS USED - R0,R5.
;
PUSH00:	MOV	R4,-(SP)	;SAVE R4
	MOV	R5,R4
	ADD	#24,R4		;ADD FUDGE TO CHECK
	CMP	R4,SP
	BHIS	PUSH02
	TST	ENDTXT		;IS USER AREA INTACT
	BNE	PUSH01		;YES, SKIP OVER INIT.
	MOV	R5,ENDTXT	;OTHERWISE REMEMBER WHERE TEXT ENDS
	INC	R5		;MAKE THE
	ASR	R5		; ADDRESS
	CLC			;  IN R5
	ASL	R5		;  AN EVEN NUMBER
PUSH01:	MOV	R0,(R5)+	;PUT ONE WORD ON THE LIST
	MOV	(SP)+,R4	;RESTORE R4
	RTS	PC
PUSH02:	OVFERR
;
; SRLST - SRL00, SEARCH USER STORAGE FOR THE FIRST ITEM HAVING THE
;	CLASS AS SPECIFIED IN R4.  THE ADDRESS OF THE FOUND ITEM IS
;	RETURNED IN R3.  UPON ENTRY, R3 MUST POINT TO THE START ADDRESS
;	OF THE LIST.  REGISTERS USED - R0,R1,R2,R3,R4.
;	AND R0 IS A MASK OF BITS TO IGNORE IN THE HEADER.
;
SRL01:	MOV	@R3,R0		;GET ITEM ON TOP OF LIST
	BIC	@SP,R0		;CLEAR OUT THE JUNK
	CMP	R0,R4		;ARE THE CLASSES THE SAME?
	BEQ	SRL05		;EXIT IF YES
	BIC	#017777,R0	;NOW MASK OFF ALL OTHER STUFF
	CMP	#040000,R0	;FIND THE CURRENT CLASS
	BNE	SRL02		;JUMP IF NOT CLASS TWO
	ADD	#20,R3		;JUMP OVER 8 ITEMS FOR CLASS TWO
	BR	SRL08
SRL00:	TST	R3
	BEQ	SRL06
	CMP	R5,SP
	BHIS	PUSH02
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	R0,-(SP)	;SAVE MASK
SRL08:	CMP	R3,SP		;HAS THE SEARCH OVERFLOWED?
	BHIS	PUSH02		;YES, GO AWAY AND DIE NICELY
	CMP	R3,R5		;OUT OF SPACE?
	BLO	SRL01		;NO
	CLR	R3		;YES, QUIT - SET NOT FOUND
SRL05:	MOV	(SP)+,R0	;RESTORE MASK
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	TST	R3		;SET STATUS BITS ON RESULT OF SEARCH
SRL06:	RTS	PC
SRL02:	BGT	SRL03		;JUMP IF CLASS 0 OR 1
	ADD	#2,R3		;CLASS 3 HERE - SKIP OVER ITEM
SRL07:	ADD	#4,R3		;SKIP OVER 2 WORDS
	BR	SRL08		;AND RE-LOOP
SRL03:	TST	R0		;CHECK FOR CLASS 0
	BEQ	SRL04
	TST	(R3)+		;CLASS ONE, SKIP ITEM
	BR	SRL08		;AND RETURN
SRL04:	MOVB	2(R3),R0	;ITEM IS CLASS ZERO, WORK IS NEEDED
	MOVB	3(R3),R1	;GET BOTH OPERANDS
	ARYLG			;COMPUTE ARRAY LENGTH
	ADD	R0,R3		;SKIP OVER PROPER NUMBER OF ITEMS
	BR	SRL07
;
; ARYLG - ARYL00, COMPUTE ARRAY LENGTH - FIRST DIM IN R0, SECOND IN
;	R1, RESULT RETURNED IN R0.  REGISTERS USED - R0,R1,R2,R3.
;
ARYL00:	BIC	#177400,R0	;CLEAR BOTH
	BIC	#177400,R1	;SIGN EXTENSIONS IF ANY
	INC	R0		;ADD ONE
	INC	R1		; TO EACH AND
	MOV	R4,-(SP)
	MOV	R3,-(SP)
	IMUL			;MULTIPLY THEM
	MOV	(SP)+,R3
	MOV	(SP)+,R4
	TST	R1		;DID THE MULTIPLY GET TOO BIG???
	BNE	ARYL01		;JUMP IF YES
	CMP	R0,#22000	;IS ARRAY LONGER THAN IS POSSIBLE?
	BHIS	ARYL01
	MULSIX			;MULTIPLY RESULT BY SIX
	CCC
	RTS	PC		;RETURN
ARYL01:	SEV
	RTS	PC		;SET ERROR IF IMPOSSIBLE ARRAY
;
; SCRNCH - SCR00, DELETE THE NUMBER OF BYTES FROM THE USER STORAGE
;	SPECIFIED BY R4.  R3 POINTS TO STARTING POINT FOR THE
;	DELETION.  REGISTERS USED - R1,R2,R3,R4,R5.
;
SCR00:	MOV	R3,R1		;GET TWO
	MOV	R1,R2		;COPIES OF THE POINTER
	ADD	R4,R1		;RESET THE REAL POINTER
	BR	SQU01		;GO SQUISH IT
;
; SQUISH - SQU00, DELETE ONE LINE OF TEXT POINTED TO BY R1
;  R1 IS NOT DESTROYED, R2 AND R3 ARE USED FOR SCRATCH
; R5 IS UPDATED WHEN DONE.  REGISTERS USED - R1,R2,R3,R5.
;
SQU00:	CLRUSR			;CLEAR THE USER SPACE IF ANY
	MOV	R1,R3		;GET TWO COPIES
	MOV	R1,R2		; OF THE POINTER
	SRCHLF			;FIND END OF LINE
SQU01:	CMP	R1,R5		;CHECK COMPLETION OF SQUEEZE
	BHIS	SQU02		;JUMP IF DONE
	MOVB	(R1)+,(R3)+	;MOVE A CHARACTER
	BR	SQU01		;MOVE THE WHOLE CHUNK
SQU02:	MOV	R3,R5		;UPDATE USER POINTER
	MOV	R2,R1		;RESTORE R1
	RTS	PC
;
; SRCHLF - SRCH00, SEARCH FOR <LF>, POINTER IN R1, WHEN DONE R1
;  POINTS ONE BYTE AFTER THE <LF>.  REGISTERS USED - R1.
;
SRCH00:	CMPB	(R1)+,#12	;IS THIS CHAR A LINE FEED?
	BNE	SRCH00		;NO
	RTS	PC
;
; FINDLN - FIND00, FIND THE LINE NUMBER IN THE TEXT WHICH CORRESPONDS
;  TO THE NUMBER SPECIFIED IN R0.  IF FOUND, SET ZERO CODE AND RETURN,
;  R1 POINTS TO BEGINNING OF LINE.  IF NOT FOUND, SET NON-ZERO, RETURN
;  WITH R1 POINTING TO THE LOGICAL INSERTION POINT FOR A NEW
;  LINE WITH THE SPECIFIED NUMBER.  
;  REGISTERS USED - R0,R1,R2,R3,R4,R5.
;
FIND00:	MOV	USR,R1		;START LOOKING AT BEGINNING OF TEXT
FIND01:	SRCHLF			;GO TO START OF LINE
	CMP	R1,R5
	BHIS	FIND05		;JUMP IF END OF TEXT
	MOV	R0,-(SP)	;SAVE LINE NUMBER
	MOV	R1,-(SP)	;SAVE LINE POINTER
	ATOI			;GET LINE NUMBER FROM TEXT
	MOV	(SP)+,R1	;RESTORE LINE POINTER
	MOV	R0,R2
	MOV	(SP)+,R0
	CMP	R0,R2		;DO LINE NUMBERS MATCH?
	BEQ	FIND03		;YES
	BGT	FIND01		;KEEP LOOKING
FIND02:	CCC			;SET NOT EQUAL
FIND03:	RTS	PC
FIND05:	CCC
	SEV			;SET OVERFLOW ON OVERFLOW
	RTS	PC
;
; GETVAR - GETV00, GET A VARIABLE AND PACK IT IN TRUNCATED ASCII INTO
;	R4.  ON RETURN R4 HAS VARIABLE, R2 HAS NEXT CHARACTER.
;	REGISTERS USED - R1,R2,R4.
;
GETV00:	SKIP			;GET A CHARACTER
	TSTCH			;ALPHABETIC?
	BEQ	GETV99		;NO
	BVS	GETV99		;NO
	BIC	#177700,R2	;TRUNCATE IT
	MOV	R2,R4		;AND
	SWAB	R4		;PACK IT IN
	ASR	R4		;THE
	ASR	R4		;HEADER WORD
	SKIP			;GET NEXT CHARACTER
	TSTCH			;NUMERIC?
	BNE	GETV01		;NO
	BIS	R2,R4		;YES, ZOT IT INTO THE HEADER
	SKIP			;GET ANOTHER CHARACTER
GETV01:	CCC
	RTS	PC		;RETURN OK
GETV99:	SEV			;SET OVERFLOW FOR BAD VARIABLE
	RTS	PC
;
; DIMCHK - DIMC00, MAKE SURE DIMENSION IN R0 IS IN BOUNDS 0 TO 255
;	REGISTERS USED - R0.
;
DIMC00:	TST	R0		;DIM .LT. 0?
	BLT	FIND02		;YES
	CMP	R0,#377		;GREATER THAN 255?
	BGT	FIND02		;YES
	SEZ			;SET EQUAL CODE IF IN BOUNDS
	RTS	PC
;
; GETNUM - GET00, GET PARAMETERS FOR COMMAND
;  R1 POINTS TO START OF USER AREA, R3 RETURNS FIRST PARAMETER, R4
;  RETURNS SECOND.  REGISTERS USED - R0,R1,R2,R3,R4.
;
GET00:	SKIP			;GET ONE CHARACTER
	TSTCH			;IS IT NUMERIC
	BNE	GET01		;NO, LOOK FOR COMMA
	DEC	R1		;YES, REPOSITION CHARACTER POINTER
	ATOI			;CONVERT FIRST ARGUMENT
	MOV	R0,-(SP)	;SAVE IT
	SKIP			;GET THE SEPARATOR
GET04:	CMP	#',,R2		;IS IT A REAL SEPARATOR?
	BNE	GET02		;NO
	ATOI			;CONVERT SECOND ARGUMENT
	TST	R0
	BEQ	GET02		;SECOND PARAMETER IS ZERO
	MOV	R0,R4
GET03:	MOV	(SP)+,R3	;SET UP FIRST ARGUMENT
	RTS	PC
GET01:	CLR	-(SP)		;NO ARGUMENTS
	BR	GET04
GET02:	CLR	R4		;SET THEM TO ZERO
	BR	GET03
;
; SAVE, OLD
;
SAVE00:	MOV	#1,SAVF
	JMP	LIST00
OLD00:	MOV	#1,OLDF
	MOV	USR,R5		;DELETE THE WHOLE
	INC	R5
	CLR	ENDTXT
	CLR	CTRLP
	CLR	LINENO
	JMP	INIT02
;
; TSTOK - TSTU00, CHECK FOR POSSIBLE USER STORAGE OVERFLOW
;  R0 HAS NUMBER OF BYTES TO ENTER.  REGISTERS USED - R0,R3,R4,R5.
;
TSTU00:	MOV	R5,R4		;GET END OF USER STORAGE
	ADD	R0,R4		;COMPUTE EXTENSION
	MOV	SP,R3		;GET SP POSITION
	SUB	#70,R3		;SUBTRACT EXPANSION FUDGE
	CMP	R3,R4		;IF SP-FUDGE .GE. R5+R0 ALL IS OK
	RTS	PC
;
; SUBSCR - SUBS00, COMPUTE A SUBSCRIPT EXPRESSION - UPON ENTRY, R1
;	POINTS TO THE ASCII CHARACTER STRING STARTING WITH THE
;	LEFT PAREN, R3 POINTS TO THE ADDRESS OF TWO STANDARD FORMAT
;	SUBSCRIPTS.  UPON EXIT, R0 POINTS TO THE DESIRED LOCATION
;	R3 IS UNCHANGED, AND R1 POINTS TO A NON-BLANK CHARACTER
;	FOLLOWING THE CLOSED PAREN.
;	REGISTERS USED - R0,R1,R2,R3,R4.
;
SUBS00:	MOV	R3,-(SP)
	EVAL			;EVALUATE THE FIRST SUBSCRIPT
	BVS	SUBS01		;SKIP IF PAREN FOUND
	CMPB	@R1,#',		;OTHERWISE MAKE SURE
	BNE	SUBS98		;COMMA IS THERE
	JSR	PC,SUBS03
	SKIP			;YES
	MOV	R0,-(SP)	;SAVE VERIFIED SUBSCRIPT
	EVAL			;GET THE SECOND SUBSCRIPT
	BVC	SUBS98		;JUMP IF NO CLOSED PAREN
	FIX			;AND FIX IT
	BMI	SUBS99
	MOV	(SP)+,R2	;GET THE
SUBS02:	MOV	@(SP),R4	;SECOND
	BIC	#177400,R4	;SUBSCRIPT LIMIT
	CMP	R0,R4		;OUT OF RANGE?
	BGT	SUBS99		;YES
	MOV	R1,-(SP)	;NO, SAVE TEXT POINTER
	MOV	R2,R1		;FIRST SUBSCRIPT
	MOV	R0,-(SP)	;SAVE SECOND SUBSCRIPT
	MOV	R4,R0		;GET Y.MAX
	INC	R0
	IMUL			;GET X*(Y.MAX+1)
	ADD	(SP)+,R0	;COMPUTE ACTUAL POSITION OF VARIABLE
	MULSIX			;  HERE AND MULTIPLY BY SIX
	MOV	(SP)+,R1	;RESTORE CHARACTER POINTER
	ADD	@SP,R0		;COMPUTE
	TST	(R0)+		; ABSOLUTE ADDRESS OF NUMBER
	MOV	(SP)+,R3	;RESTORE R3
	RTS	PC
SUBS01:	JSR	PC,SUBS03
	MOV	R0,R2		;SAVE FIRST SUBSCRIPT
	CLR	R0		;SET SECOND SUBSCRIPT TO ZERO
	BR	SUBS02		;GO BACK TO MAIN LINE
SUBS98:	SBSERR			;BADLY FORMED SUBSCRIPT
SUBS99:	SUBERR			;SUBSCRIPT OUT OF RANGE
SUBS03:	FIX			;FIX IT
	BMI	SUBS99
	MOV	@2(SP),R4	;GET BOTH SUBSCRIPT LIMITS
	SWAB	R4		;I WANT THE FIRST ONE ONLY
	BIC	#177400,R4	; ONLY
	CMP	R0,R4		; OUT OF RANGE?
	BGT	SUBS99		;YES
	RTS	PC
	.EOT			;END OF TAPE 2
