.NLIST

R0	=	%0
R1	=	%1
R2	=	%2
R3	=	%3
R4	=	%4
R5	=	%5
SP	=	%6
PC	=	%7

AC0	=	%0			;FLOATING POINT 0
AC1	=	%1			;FLOATING POINT 1
AC2	=	%2			;FLOATING POINT 2
AC3	=	%3			;FLOATING POINT 3
AC4	=	%4			;FLOATING POINT 4
AC5	=	%5			;FLOATING POINT 5

PS	=	177776			; PROCESSOR STATUS
BR0	=	0			; PRIORITIES
BR1	=	40
BR2	=	100
BR3	=	140
BR4	=	200
BR5	=	240
BR6	=	300
BR7	=	340

	.MACRO	DISABLE,ARG
		BIC	#300,ARG
	.ENDM

	.MACRO	ENABLE,ARG
		BIS	#100,ARG
	.ENDM

	.MACRO	ACKINT,ARG
		TST	ARG
	.ENDM

	.MACRO	SWITCH,ARG1,ARG2
		MOV	ARG1,-(SP)
		MOV	ARG2,ARG1
		MOV	(SP)+,ARG2
	.ENDM

	.MACRO	PUSH,ARG
		MOV	ARG,-(SP)
	.ENDM

	.MACRO	POP,ARG
		MOV	(SP)+,ARG
	.ENDM

	.MACRO	SAVE ARG1,ARG2,ARG3,ARG4,ARG5,ARG6
	.NARG	NUM
	.IF EQ	NUM	;IF NUMBER OF ARGUMENTS IS 0 SAVE ALL REGISTERS
					PUSH	R0
					PUSH	R1
					PUSH	R2
					PUSH	R3
					PUSH	R4
					PUSH	R5
	.IFF		;IF NUMBER OF ARGUMENTS .NE. 0 THEN FOLLOWING
	.IIF NB,ARG1,PUSH	ARG1	;IF ARG1 NOT BLANK PUSH
	.IIF NB,ARG2,PUSH	ARG2
	.IIF NB,ARG3,PUSH	ARG3
	.IIF NB,ARG4,PUSH	ARG4
	.IIF NB,ARG5,PUSH	ARG5
	.IIF NB,ARG6,PUSH	ARG6
	.ENDC
	.ENDM

	.MACRO	RESTORE ARG1,ARG2,ARG3,ARG4,ARG5,ARG6
	.NARG	NUM	;NUMBER OF ARGUMENTS
	.IF EQ	NUM	;NO ARGUMENTS SPECIFIED RESTORE ALL REGISTERS
					POP	R5
					POP	R4
					POP	R3
					POP	R2
					POP	R1
					POP	R0
	.IFF		;IF ARGUMENTS SPECIFIED RESTORE THE ARGUMENTS
	.IIF NB,ARG1,POP	ARG1	;IF ARGUMENT 1 NOT BLANK POP IT.
	.IIF NB,ARG2,POP	ARG2
	.IIF NB,ARG3,POP	ARG3
	.IIF NB,ARG4,POP	ARG4
	.IIF NB,ARG5,POP	ARG5
	.IIF NB,ARG6,POP	ARG6
	.ENDC
	.ENDM


	.MACRO	PUSHFS			;SAVE FPP PROCESSOR STATUS
		STFPS	-(SP)
	.ENDM

	.MACRO	POPFS			;RESTORE FPP STATUS
		LDFPS	(SP)+
	.ENDM

	.MACRO	SAVEFS			;SAVE FPP PROCESSOR STATUS
		STFPS	-(SP)
	.ENDM

	.MACRO	RESTFS			;RESTORE FPP STATUS
		LDFPS	(SP)+
	.ENDM

	.MACRO	PUSHF,ARG		;PUSH FLOATING POINT REGISTER
		STF	ARG,-(SP)
	.ENDM

	.MACRO	POPF,ARG		;POP FLOATING POINT REGISTER
		LDF	(SP)+,ARG
	.ENDM

	.MACRO	SAVEF ARG1,ARG2,ARG3,ARG4	 ;SAVE THE FPP REGISTERS
	.NARG	NUM
	.IF EQ	NUM	;IF NUMBER OF ARGUMENTS IS 0 SAVE ALL REGISTERS
			;IF YOU ARE USING JUST THE STRAIGHT SAVEF WITH
			;NO ARGUMENTS, MAKE SURE THAT YOU SAVE THE STATUS
			;FIRST!!!!!!
					PUSHF	AC0
					PUSHF	AC1
					PUSHF	AC2
					PUSHF	AC3
					LDF	AC4,AC0
					PUSHF	AC0
					LDF	AC5,AC0
					PUSHF	AC0
	.IFF		;IF NUMBER OF ARGUMENTS .NE. 0 THEN FOLLOWING
	.IIF NB,ARG1,PUSHF	ARG1	;IF ARG1 NOT BLANK PUSH
	.IIF NB,ARG2,PUSHF	ARG2
	.IIF NB,ARG3,PUSHF	ARG3
	.IIF NB,ARG4,PUSHF	ARG4
	.ENDC
	.ENDM

	.MACRO	RESTF ARG1,ARG2,ARG3,ARG4 ;POP THE FIRST FOUR FPP REGISTERS
	.NARG	NUM	;NUMBER OF ARGUMENTS
	.IF EQ	NUM	;NO ARGUMENTS SPECIFIED RESTORE ALL REGISTERS
					POPF	AC0
					STF	AC0,AC5
					POPF	AC0
					STF	AC0,AC4
					POPF	AC3
					POPF	AC2
					POPF	AC1
					POPF	AC0
	.IFF		;IF ARGUMENTS SPECIFIED RESTORE THE ARGUMENTS
	.IIF NB,ARG1,POPF	ARG1	;IF ARGUMENT 1 NOT BLANK POP IT.
	.IIF NB,ARG2,POPF	ARG2
	.IIF NB,ARG3,POPF	ARG3
	.IIF NB,ARG4,POPF	ARG4
	.ENDC
	.ENDM

	.MACRO	CALL,ARG,PASSING,A,B,C,D,E,F
	.NARG	COUNT
	.IF	EQ,COUNT-1				;ONE ARGUMENT
					JSR	PC,ARG

		.IFF			;ELSE

					SAVE	R5	; SAVE PARAMETER POINTER
					PASSING	A,B,C,D,E,F ; SET UP PARAMETER LIST
					JSR	PC,ARG
					RESTORE	R5
	.ENDC
	.ENDM

	.MACRO	PASSING,A,B,C,D,E,F,?BYPASS
					MOV	#.+6,R5	; PARAMETER POINTER
					BR	BYPASS	; JUMP AROUND LIST
	.WORD	COUNT-2		;NUMBER OF ARGUMENTS
	.IIF	NB,A	.WORD	A
	.IIF	NB,B	.WORD	B
	.IIF	NB,C	.WORD	C
	.IIF	NB,D	.WORD	D
	.IIF	NB,E	.WORD	E
	.IIF	NB,F	.WORD	F
BYPASS:
	.ENDM

	.MACRO	$LABEL	LAB
	Z'LAB:
	.ENDM

	.MACRO	$BNE	LAB
	BNE	Z'LAB
	$LAB$ = $LAB$+1
	.ENDM

	.MACRO	LSHIFT	ARG,COUNT	 ;NO MODE 67 ALLOWED
	.NTYPE	TYP,ARG
	.NTYPE	TYP2,COUNT

	.IIF	EQ,TYP&70-20	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-30	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-40	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-50	.ERROR	;ARG NOT ALLOWED

	.IIF	NDF,$LAB$	$LAB$ = 1
	.IF	DF,EIS			;IF HARDWARE
		.IF	EQ,TYP&70	;IF REGISTER MODE
			.IIF	EQ,TYP2-67	ASH	#'COUNT,ARG
			.IIF	NE,TYP2-67	ASH	COUNT,ARG
		.IFF			;ELSE
			$REG = 0	;REGISTER 0
			.IF	NE,TYP2&7-7	;A REGISTER MODE
				.IF	EQ,TYP2&7-$REG
					$REG=$REG+1 ;USE REG 1 INSTEAD
				.IIF	EQ,TYP&7-$REG  $REG=$REG+1 ;USE REG 2 INSTEAD
				.ENDC
			.ENDC
			.IF	NE,TYP&7-7 ;REGISTER MODE
				.IF	EQ,TYP&7-$REG
					$REG=$REG+1 ;USE REG 1 INSTEAD
				.IIF	EQ,TYP2&7-$REG  $REG=$REG+1 ;USE REG 2 INSTEAD
				.ENDC
			.ENDC
				SAVE	R0+$REG
				MOV	ARG,R0+$REG
				.IIF	EQ,TYP2-67	ASH	#'COUNT,R0+$REG
				.IIF	NE,TYP2-67	ASH	COUNT,R0+$REG
				MOV	R0+$REG,ARG
				RESTORE	R0+$REG
		.ENDC

	.MEXIT
	.ENDC


	.IF	DF,EAE			;IF EAE HARDWARE
	.IF	EQ,TYP2-67
		.IF	GE,COUNT-16.
		.ERROR	;COUNT > 16 FOR LEFT SHIFTS
		.MEXIT
		.ENDC
	.ENDC
		AAC = 177302
		AMQ = AAC + 2
		ASC = AAC + 12		;LOGICAL SHIFT
		CLR	@#AMQ		;CLEAR HIGH BITS
		MOV	ARG,@#AAC
			.IIF	EQ,TYP2-67	MOV	#'COUNT,@#ASC
			.IIF	NE,TYP2-67	MOV	COUNT,@#ASC
		MOV	@#AAC,ARG	;RESTORE ARGUMENT
	.MEXIT
	.ENDC

					;NO HARDWARE
	.IF	EQ,TYP2-67
		.IF	GE,COUNT-16.
		.ERROR	;COUNT > 16 FOR LEFT SHIFTS
		.MEXIT
		.ENDC

		.IF	GT,COUNT-7.	;7 < COUNT < 15
			SWAB	ARG
			BIC	#377,ARG
			LSHIFT	ARG,COUNT-8.
		.IFF			;0 < COUNT < 7
			.REPT	COUNT
				ASL	ARG
			.ENDR
		.MEXIT
		.ENDC

	.IFF
			$LABEL	\$LAB$
			ASL	ARG
			DEC	COUNT
			$BNE	\$LAB$
	.ENDC
	.ENDM


	.MACRO	RSHIFT	ARG,COUNT,?LOOP,?BYP,?BYP2,?BYP3  ;NO MODE 67 ALLOWED
	.NTYPE	TYP,ARG
	.NTYPE	TYP2,COUNT

	.IIF	EQ,TYP&70-20	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-30	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-40	.ERROR	;ARG NOT ALLOWED
	.IIF	EQ,TYP&70-50	.ERROR	;ARG NOT ALLOWED

	.IF	DF,EIS			;IF HARDWARE
		.IF	EQ,TYP&70	;IF REGISTER MODE
			.IF	EQ,TYP2-67
				CLC
				ROR	ARG
				COUNT = COUNT-1
				.IIF	GT,COUNT	ASH #-'COUNT,ARG
			.ENDC
			.IF	NE,TYP2-67
				CLC
				ROR	ARG
				DEC	COUNT
				BLE	BYP2
				ASH	COUNT,ARG
			BYP2:
			.ENDC
		.IFF			;ELSE
			$REG = 0	;REGISTER 0
			.IF	NE,TYP2&7-7	;A REGISTER MODE
				.IF	EQ,TYP2&7-$REG
					$REG=$REG+1 ;USE REG 1 INSTEAD
				.IIF	EQ,TYP&7-$REG  $REG=$REG+1 ;USE REG 2 INSTEAD
				.ENDC
			.ENDC
			.IF	NE,TYP&7-7 ;REGISTER MODE
				.IF	EQ,TYP&7-$REG
					$REG=$REG+1 ;USE REG 1 INSTEAD
				.IIF	EQ,TYP2&7-$REG  $REG=$REG+1 ;USE REG 2 INSTEAD
				.ENDC
			.ENDC
				CLC
				ROR	ARG
			.IF	EQ,TYP2-67
				.IF	GT,COUNT-1
				COUNT = COUNT-1
				SAVE	R0+$REG
				MOV	ARG,R0+$REG
				ASH 	#-'COUNT,R0+$REG
				MOV	R0+$REG,ARG
				RESTORE	R0+$REG
				.ENDC
			.MEXIT
			.ENDC
			.IF	NE,TYP2-67
				DEC	COUNT
				BLE	BYP3
				SAVE	R0+$REG
				MOV	ARG,R0+$REG
				ASH	COUNT,R0+$REG
				MOV	R0+$REG,ARG
				RESTORE	R0+$REG
			BYP3:
			.MEXIT
			.ENDC
		.ENDC

	.MEXIT
	.ENDC


	.IF	DF,EAE			;IF EAE HARDWARE
	.IF	EQ,TYP2-67
		.IF	GE,COUNT-16.
		.ERROR	;COUNT > 16 FOR RIGHT SHIFTS
		.MEXIT
		.ENDC
	.ENDC
		AAC = 177302
		AMQ = AAC + 2
		ASC = AAC + 12		;LOGICAL SHIFT
		CLR	@#AMQ		;CLEAR HIGH BITS
		MOV	ARG,@#AAC
			.IIF	EQ,TYP2-67	MOV	<#->'COUNT,@#ASC
			.IIF	NE,TYP2-67	MOV	COUNT,@#ASC
		MOV	@#AAC,ARG	;RESTORE ARGUMENT
	.MEXIT
	.ENDC

					;NO HARDWARE
	.IF	EQ,TYP2-67
		.IF	GE,COUNT-16.
		.ERROR	;COUNT > 16 FOR RIGHT SHIFTS
		.MEXIT
		.ENDC

		.IF	GT,COUNT-7.	;7 < COUNT < 15
			SWAB	ARG
			BIC	#177400,ARG
			RSHIFT	ARG,COUNT-8.
		.IFF			;0 < COUNT < 7
			.IIF	EQ,COUNT	.MEXIT
			CLC
			ROR	ARG
			.REPT	COUNT-1
				ASR	ARG
			.ENDR
		.MEXIT
		.ENDC

	.IFF
			CLC
			ROR	ARG
			DEC	COUNT
			BEQ	BYP
		LOOP:
			ASR	ARG
			DEC	COUNT
			BNE	LOOP
		BYP:
	.ENDC
	.ENDM


	.MACRO	MUL$10,ARG		; MULTIPLY ARG BY 10
					ASL	ARG	; MULTIPLY BY 2
					PUSH	ARG	; SAVE 2*ARG
					ASL	ARG	; 2*ARG
					ASL	ARG	; 2*ARG
					ADD	(SP)+,ARG ; 10*ARG=8*ARG+2*ARG
	.ENDM


;;;; DIVIDE MACROS CONTROLLED BY EIS - FLAG FOR EXTENDED INSTRUCTION SET(FIXED POINT KE11-E.
;;;; IF HARDWARE EXISTS FOR DIVIDE IT IS DONE IN THE HARDWARE.  OTHERWISE
;;; IT IS DONE BY SUCCESSIVE SUBTRACTIONS OF THE POWERS OF THE DIVISOR.
;;;; USING THE BINARY EXPANSION OF THE FRACTION WOULD BE SLIGHTLY
;;; FASTER. IT USES LESS ITERATIONS BUT EACH ITERATION IS LONGER THAN THE
;;; THE COMPARABLE ITERATION IN A SUBTRACT SEQUENCE.  THE TWO MAJOR ADVANTAGES
;;; OF THE SUBTRACT SEQUENCE ARE THE ABILITY TO USE THE
;;; SAME MACRO SEQUENCE WITH A DIFFERENT POWER TABLE AND THAT IT WORKS FOR
;;; THE FULL RANGE OF UNSIGNED NUMBERS CONTAINED IN A SINGLE PDP WORD.
;;; THE BINARY METHOD BREAKS DOWN AT SUFFICIENTLY HIGH NUMBERS.
;;; ALSO THE ALGORITHM CHANGES WITH EACH DIVISOR AND DOESN'T PRODUCE THE
;;; MODULUS IMMEDIATELY AS DOES THE SUBTRACTION METHOD.

	.MACRO	DIV$10 ARG		; DIVIDE BY 10.
					$$DIV	ARG,#10.,#$TENS ; POWER LIST EQ 10000,1000,100,10,1
	.ENDM

	.MACRO	$$DIV ARG,DIVISOR,POWERLIST ; DETERMINE HARDWARE OR SOFTWARE DIVIDE
	.NTYPE	TYP,ARG		;TYPE OF ARGUMENT
	.IF	DF,EIS				;IF HARDWARE EXISTS
					HARD$DIVIDE ARG,DIVISOR ; DO HARDWARE DIV
	.IFF					;ELSE
					SOFT$DIVIDE ARG,POWERLIST ; SOFTWARE DIVIDE USING SUBTRACTION

	.ENDC
	.ENDM

	.MACRO	HARD$DIVIDE ARG,DIVISOR	; HARDWARE DIVIDE
	.IF	EQ,TYP&70			;IF REGISTER MODE
					REG$DIV	ARG,DIVISOR ;

	.IFF					;ELSE
					MEM$DIV	ARG,DIVISOR ; DIVIDE WITH MEMORY ADDRESS ARGUMENT
	.ENDC
	.ENDM

	.MACRO	MEM$DIVIDE ARG,DIVISOR	; DIVIDE WITH MEMORY ARGUMENT
					SAVE	PS,R0,R1 ; SAVE	REGISTERS AND PS
					MOV	ARG,R0	; SET UP FOR HARDWARE DIV
					MOV	ARG+2,R1 ;
					DIV	DIVISOR,R0 ; DO THE DIVIDE
					MOV	@#PS,4(SP) ; SAVE STATUS BITS CORRECTLY
					MOV	R0,ARG	; MOVE RESULTS TO ARG
					MOV	R1,ARG+2 ;
					RESTORE	R1,R0,@#PS ; RESTORE	REGISTERS AND PS
	.ENDM

	.MACRO	REG$DIVIDE ARG,DIVISOR	; DIVIDE IN REGISTERS
					$OFF=0
	.IF	NE,TYP&1			;CHECK FOR ODD REGISTER
					$OFF=1		; IF SO SAVE AND RESTORE REG-1
					SAVE	ARG-1
					CLR	ARG-1	; SET UP FOR DIVIDE
	.ENDC

					DIV	DIVISOR,ARG-$OFF ; CORRECT DIVIDE

	.IF	NE,TYP&1			;IF WE MUST RESTORE ARG-1
					RESTORE	ARG-1
	.ENDC
	.ENDM

	.MACRO	SOFT$DIVIDE ARG,POWERLIST ; SUCCESSIVE SUBTRACTIONS
	.IF	EQ,TYP&70			;REGISTER MODE
					$OFF	= 1	; DIFFERENTIAL =1 FOR REGISTERS
					$REG=4		; TRY R4 IF FREE
		.IIF GE,TYP-4,$REG=0		;ELSE R0

	.IFF					;ELSE IF NOT REGISTER
					$OFF	= 2	; FOR MEMORY DIFFERENTIAL = 2
					$REG=0
	.ENDC

					SAVE	R0+$REG	; SAVE LIST POINTER REG
					MOV	POWERLIST,R0+$REG ; SET UP POINTER TO POWER LIST
					$DIV	ARG,$REG ; DIVIDE BY SUCCESSIVE SUBTRACTIONS
					RESTORE	R0+$REG
	.ENDM

	.MACRO	$DIV ARG,$REG,?L1,?L2,?L3 ; SOFTWARE DIVIDE
					CLR	ARG	; CLR QUOTIENT AREA SUMMER
L1:					IF	ARG+$OFF LO ($REG) L2 ; IF LT CURRENT POWER OF DIVISOR
					SUB	($REG),ARG+$OFF ; DECREASE DIVIDEND
					ADD	2($REG),ARG ; ADD DIVISOR TO ONE LESS POWER
					BR	L1	; LOOP

L2:					IF	2($REG) EQ #1 L3 ; IF DONE EXIT LEAVING MODULUS IN ARG+$OFF
					TST	($REG)+	; ELSE NEXT LOWER POWER OF DIVISOR
					BR	L1	; SUBTRACT SEQUENCE AGAIN

L3:							; DONE. QUOTIENT IN ARG, REMAINDER IN ARG+$OFF
	.ENDM




;THE FOLLOWING SERIES OF MACROS ALLOWS THE USE OF AN
;IF STATEMENT IN A VERY HIGH LEVEL.  ALSO ALLOWED IS THE
;USE OF A GOTO STATEMENT
;;
;L E G A L   F O R M A T S
;--------------------------
;
;	IF ARG1 REL DEST             ;TESTING ARG1 IF REL HOLD GOTO DEST
;       IF ARG1 REL GOTO DEST        ;SAME AS ABOVE BUT USES A JMP
;       IF ARG1 REL ARG2 DEST        ;IF REL EXISTS BETWEEN ARG1 AND ARG2 GOTO DEST
;       IF ARG1 REL ARG2 GOTO DEST   ;SAME AS ABOVE BUT BRANCHES VIA JMP
;       IF ARG1 .AND. ARG2 REL DEST    ;IF REL HOLDS ON LOGICAL PRODUCT GO TO DEST
;       IF ARG1 .AND. ARG2 REL GOTO DEST  ;  SAME AS ABOVE BUT BRANCH IS VIA JMP
;
;       GOTO DEST                    ; JMP DEST

;;
; ALL OF THE AVOVE CAN ALSO BE DONE IN BYTE MODE BY SUBSTITUTING IFBYTE FOR IF.
;NOTE BECAUSE OF LIMITATIONS IN ASSEMBLER GENERATED SYMBOLS ANY MODULE
;CAN HAVE UP TO 64 USES OF THE GOTO STATEMENT OR GOTO VARIATION OF THE
;IF STATEMENT.
;
					; ARG1 = 1ST ARGUMENT
					; ARG2 = 2ND ARGUMENT
					; REL  = RELATIONSHIP
					; DEST = DESTINATION
					; DUMMY =
					; MODE =  WORD OR BYTE MODE
					;


	.MACRO	GO.TO,REL,DEST,?BYPASS
					B'REL	.+4
					BR	BYPASS
					JMP	DEST
BYPASS:
	.ENDM
	.MACRO	GOTO,REL,DEST
	.NARG	COUNT
	.IF EQ	COUNT-1	;IF ONE PARAMETER
					JMP	REL	; GO TO THE DEST

	.IFF		;OTHERWISE TWO PARAMETERS

					GO.TO	REL,DEST
	.ENDC
	.ENDM


	.MACRO	IF3ARG,ARG1,REL,DEST,MODE
					TST'MODE ARG1
					B'REL	DEST
	.ENDM


	.MACRO	IF4ARG,ARG1,REL,ARG2,DEST,GO.2,MODE

	.IF	IDN	ARG2,GO.2	;IF GOTO TYPE
					TST'MODE ARG1
					GOTO	REL,DEST

	.IFF
					CMP'MODE ARG1,ARG2
					B'REL	DEST
	.ENDC
	.ENDM


	.MACRO	IF5ARG,ARG1,REL,ARG2,DUMMY,DEST,GO.2,MODE
	.IF	IDN	DUMMY,GO.2
					CMP'MODE ARG1,ARG2
					GOTO	REL,DEST

	.IFF
					BIT'MODE ARG1,ARG2
					B'DUMMY	DEST
	.ENDC
	.ENDM

	.MACRO	IF6ARG,ARG1,.AND.,ARG2,REL,GO.2,DEST,MODE
					BIT'MODE ARG1,ARG2
					GOTO	REL,DEST
	.ENDM


	.MACRO	IFBYTE,ARG1,REL,ARG2,DUMMY,DEST,GO.2
	.NARG COUNT
	.IF	LE,COUNT-2
		.ERROR	;LESS THAN TWO ARGUMENTS
		.MEXIT
	.ENDC
	.IF EQ COUNT - 3
					IF3ARG	ARG1,REL,ARG2,B
	.ENDC
	.IF EQ COUNT - 4
					IF4ARG	ARG1,REL,ARG2,DUMMY,GOTO,B
	.ENDC
	.IF EQ COUNT - 5
					IF5ARG	ARG1,REL,ARG2,DUMMY,DEST,GOTO,B
	.ENDC
	.IF EQ COUNT-6
					IF6ARG	ARG1,REL,ARG2,DUMMY,DEST,GO.2,B
	.ENDC
	.ENDM

	.IF	NDF,SAL11
;	USE ALTERNATE FORM (IF.) WITH SAL11
	.MACRO	IF,ARG1,REL,ARG2,DUMMY,DEST,GO.2
	.NARG COUNT
	.IF	LE,COUNT-2
		.ERROR	;LESS THAN TWO ARGUMENTS
		.MEXIT
	.ENDC
	.IF EQ COUNT - 3
					IF3ARG	ARG1,REL,ARG2
	.ENDC
	.IF EQ COUNT - 4
					IF4ARG	ARG1,REL,ARG2,DUMMY,GOTO
	.ENDC
	.IF EQ COUNT - 5
					IF5ARG	ARG1,REL,ARG2,DUMMY,DEST,GOTO
	.ENDC
	.IF EQ COUNT-6
					IF6ARG	ARG1,REL,ARG2,DUMMY,DEST,GO.2
	.ENDC
	.ENDM
	.ENDC

	.MACRO	IF.,ARG1,REL,ARG2,DUMMY,DEST,GO.2	;ALT FORM FOR SAL11
	.NARG COUNT
	.IF	LE,COUNT-2
		.ERROR	;LESS THAN TWO ARGUMENTS
		.MEXIT
	.ENDC
	.IF EQ COUNT - 3
					IF3ARG	ARG1,REL,ARG2
	.ENDC
	.IF EQ COUNT - 4
					IF4ARG	ARG1,REL,ARG2,DUMMY,GOTO
	.ENDC
	.IF EQ COUNT - 5
					IF5ARG	ARG1,REL,ARG2,DUMMY,DEST,GOTO
	.ENDC
	.IF EQ COUNT-6
					IF6ARG	ARG1,REL,ARG2,DUMMY,DEST,GO.2
	.ENDC
	.ENDM

	.MACRO	DADD,ARG1,ARG2		; DOUBLE PRECISION ADD- REQUIRES 2 WORD ARGUMENTS IN MEMORY
					ADD	ARG1,ARG2
					ADC	2+ARG2
					ADD	2+ARG1,2+ARG2
	.ENDM

	.MACRO	DSUB,ARG1,ARG2		; DOUBLE SUBTRACT
					SUB	ARG1,ARG2
					SBC	2+ARG2
					SUB	2+ARG1,2+ARG2
	.ENDM

	.MACRO	DINC,ARG		; DOUBLE PRECISION  INCREMENT
					ADD	#1,ARG	; INCREMENT THAT PROPERLY SETS C BIT
					ADC	2+ARG
	.ENDM

	.MACRO	DDEC,ARG		; DOUBLE PRECISION DECREMENT
					SUB	#1,ARG	; DEC THAT PROPERLY SETS C BIT
					SBC	2+ARG
	.ENDM

	.MACRO	DMOV,ARG1,ARG2		; DOUBLE PRECISION MOVE OF TWO WORDS
					MOV	ARG1,ARG2
					MOV	2+ARG1,2+ARG2
	.ENDM

	.MACRO	.DOUBLE,NUM
	.NARG	C
	.IF	EQ C
COUNT					=	1
	.IFF
COUNT					=	NUM
	.ENDC
	.REPT	COUNT
					.WORD	0,0
	.ENDR
	.ENDM

	.MACRO	SET,ARG			; SET FLAG TO NON-ZERO
					MOV	#1,ARG
	.ENDM

	.MACRO	.AND.,ARG1,ARG2,MODE
	.NTYPE	TYP,ARG2
		.IF	NE,TYP-27
					MOV'MODE ARG2,-(SP)
					COM'MODE (SP)
					BIC'MODE (SP)+,ARG1
		.IFF
					BIC'MODE ARG2*<-1>-1,ARG1
		.ENDC
	.ENDM

	.MACRO	.OR.,ARG1,ARG2,MODE
					BIS'MODE ARG2,ARG1
	.ENDM

	.IF	NDF,SAL11
	.MACRO	AND,ARG1,ARG2,MODE
	.NTYPE	TYP,ARG2
		.IF	NE,TYP-27
					MOV'MODE ARG2,-(SP)
					COM'MODE (SP)
					BIC'MODE (SP)+,ARG1
		.IFF
					BIC'MODE ARG2*<-1>-1,ARG1
		.ENDC
	.ENDM

	.MACRO	OR,ARG1,ARG2,MODE
					BIS'MODE ARG2,ARG1
	.ENDM
	.ENDC

	.MACRO	PLUS,ARG1,ARG2,MODE
	.IF	IDN,ARG2,<#1>
					INC	ARG1
	.IFF
					ADD	ARG2,ARG1
	.ENDC
	.ENDM

	.MACRO	MINUS,ARG1,ARG2,MODE
	.IF	IDN,ARG2,<#1>
					DEC	ARG1
	.IFF
					SUB	ARG2,ARG1
	.ENDC
	.ENDM

	.MACRO	SHIFT,ARG,COUNT,MODE
	.NTYPE	TYPP,COUNT
	.IF	EQ,TYPP-67
		.IF	GE,COUNT
					LSHIFT	ARG,COUNT
		.IFF
					MCNT	= 0-COUNT
					RSHIFT	ARG,MCNT
		.ENDC
	.IFF
		LSHIFT	ARG,COUNT
	.ENDC
	.ENDM

	.MACRO	COMPUTE A,O2,C,O3,D,O4,E,O5,F,O6,G ; COMPUTE MACRO

	.NCHR	CHARS,O2				;CHECK IF SINGLE CHAR
	.IIF	EQ,CHARS	.MEXIT			;IF NO ARGUMENT EXIT FROM MACRO
	.IF	EQ,CHARS-1
		.IIF	IDN,O2,<&>	.AND.	A,C
		.IIF	IDN,O2,<!>	OR	A,C
		.IIF	IDN,O2,<+>	PLUS	A,C
		.IIF	IDN,O2,<->	MINUS	A,C

	.IFF
					O2	A,C
	.ENDC

	.IF	NB,O3					;IF MORE TO DO
					COMPUTE	A,O3,D,O4,E,O5,F,O6,G ; DO THE REST
	.ENDC
	.ENDM

	.MACRO	LET A,O1,B,O2,C,O3,D,O4,E,O5,F,O6,G ; ALLOW UP TO 6 OPERATIONS
	.IF	IDN,O1,<=>	;FIRST OPERATOR MUST BE =
		.IF	IDN,O2,<=>			;IF 2 = DOUBLE REPLACE
					LET	B,O2,C,O3,D,O4,E,O5,F,O6,G
					MOV	B,A	; MOV RESULT TO A
			.IFF				;ELSE
			.IIF	DIF,A,B	MOV	B,A
					COMPUTE	A,O2,C,O3,D,O4,E,O5,F,O6,G
		.ENDC
	.ENDC

	.IF	DIF,O1,<=>
	.ERROR	;NO = IN LET MACRO
	.ENDC
	.ENDM

;;;;;; FOR MAT OF DO MACRO
;	DO INDEX = LO,HI,INC
;	ENDDO INDEX
;
;	LO HI AND INC ARE INTEGER CONSTANTS
;
$LEV	=0
$$$$LB	=1
	.MACRO	DO,INDEX,DUMMY,LO,HI,INC
$LEV					=$LEV+1
					MOV	#'LO,INDEX
					$SETDO	LO,HI,INC,\$LEV
					$SETLB	\$$$$LB,\$LEV
	.ENDM
	.MACRO	$SETLB,LAB,LEV
$PC'LAB					=	.
$L'LAB:
$LB'LEV					=LAB
$$$$LB					=$$$$LB+1
	.ENDM

	.MACRO	$SETDO,LOW,HI,INC,$LEV
$REL'$LEV				=-1
	.IF	LT,HI-LOW
		.IIF	GE,HI,$REL'$LEV=-1
		.IIF	LT,HI,$REL'$LEV=1
	.IFF
		.IIF	GE,HI,$REL'$LEV=1
		.IIF	LT,HI,$REL'$LEV=-1
	.ENDC
$INC'$LEV				=INC
$LAB'$LEV				=$$$$LB
$LIM'$LEV				=HI
	.ENDM
	.MACRO	ENDDO INDEX
					$$ENDDO	INDEX,\$LEV
	.ENDM
	.MACRO	$$ENDDO,INDEX,LEV
	.NTYPE	$$$TYP,INDEX
	.IF	EQ,<$LIM'LEV-1>!<$$$TYP&70>!<$INC'LEV+1>!<EIS-1>
					$SOB	INDEX,\<$LB'LEV>
	.IFF
					$ENDDO	INDEX,\$LEV
	.ENDC
$LEV					=$LEV-1
	.ENDM

	.MACRO	$SOB,INDEX,DEST
$$$DST					=126.+$L'DEST-.
	.IF	GT,126.+$L'DEST-.	; IF NOT TOO FAR
					SOB	INDEX,$L'DEST
	.IFF
					BR	.+6	; BR TO SOB
					JMP	@#$L'DEST
					SOB	INDEX,.-4
	.ENDC
	.ENDM

	.MACRO	$ENDDO INDEX,LEV
$$$FLG					=0
	.IF	EQ,$INC'LEV-1	; IF INCREMENT IS BETTER
$$$FLG					=	1
					INC	INDEX
	.ENDC
	.IF	EQ,$INC'LEV+1	; IF DECREMENT IS BETTER
$$$FLG					=	1
					DEC	INDEX
	.ENDC
	.IF	EQ,$$$FLG		; IF NO OPTIMIZATION DONE
					ADD	#$INC'LEV,INDEX
	.ENDC
$$$FLG					=	0
	.IF	EQ,$LIM'LEV		; COMPARE TO ZERO
$$$FLG					=	1	; NO TEST NEED BE DONE
	.ENDC
	.IF	EQ,$$$FLG		; OTHERWISE MUST TEST
					CMP	INDEX,#$LIM'LEV
	.ENDC
$DST'LEV				=.-$PC'LEV
	.IF	LT,$REL'LEV
					$JMP	\<$LB'LEV>,HIS
	.IFF
					$JMP	\<$LB'LEV>,LOS
	.ENDC
	.ENDM
	.MACRO	$JMP DEST,REL
	.IF	GT,256.+$L'DEST-.	; BRANCH LEGAL
					B'REL	$L'DEST
	.IFF
					B'REL	.+4
					BR	.+6
					JMP	@#$L'DEST
	.ENDC
	.ENDM
	.LIST
	.NLIST	TTM