.TITLE	MRO

;&.LITERAL
;+	RUN-TIME MEMORY RESIDENT OVERLAY HANDLER
;	MRO					;PN-109
;	MRO IS RUN-TIME OVERLAY HANDLER UTILIZING THE MEMORY OVER
;	28K FOR OVERLAYING A CERTAIN OVERLAY SEGMENTS.   THEY CAN
;	BE PERMANENTLY OR TEMPORALILY OVERLAYED.
;
;
;	*****MODIFICATION FOR APPLICATION TO RTMULTI VER. 3*****
;
;	COPYRIGHT	1978
;	FERMI NATIONAL ACCELERATOR LABORATORY
;	P.O. BOX 500
;	BATAVIA, ILLINOIS   60510
;	WORK SUPPORTED BY DEPARTMENT OF ENERGY,
;	THE UNITED STATES OF AMERICA
;
;
;	ASSEMBLY:
;		MRO,LP:=MRO
;		MRO,LP:=OVLHDR,MRO	;FOR NO MAP WITH RSN=1
;	ASSEMBLY PARAMETERS:
;	RSMX	=MAXIMUM NUMBER OF REGION SETS ALLOWED
;	RGMX	=MAXIMUM NUMBER OF REGIONS ALLOWED
;	SGMX	=MAXIMUM NUMBER OF SEGMENTS ALLOWED
;	RS1NMP	= 1  FOR KT11 ENABLED DURING REGION SET 1 USE
;		= 0  FOR KT11 DISABLED DURING REGION SET 1 USE
;
;	AUTHORS OF THE ORIGINAL
;	DATE			NAMES
;	JULY 20,1978		D. RITCHIE AND Y. KANG
;
;	MODIFICATIONS:
;	DATE			NAMES			MODIFICATIONS
;	OCT 20, 1978		D. RITCHIE AND Y. KANG APPLICATION TO 		
;							RTMULTI V3
;
;-
;.END LITERAL
;

	.MCALL	.PARAM,.PRINT,.EXIT
	.PARAM
	
	.GLOBL	MROI,MMINIT

	;DEFAULTS:
	.IIF NDF,	RSMX,	RSMX=16.
	.IIF NDF,	RGMX,	RGMX=10.
	.IIF NDF,	SGMX,	SGMX=50.
	.IIF NDF,	RS1NMP,	RS1NMP=0
	.IIF NDF,	RSLCL,	RSLCL=1	;USE DEFAULT RSRCH
	.IIF NDF,	NSGUMX,	NSGUMX=20.	;MAX. SEG NOS. ALLOWED
						;IN UPPER REGION SETS

;	ASSEMBLY PARAMETERS WITH RESPECT TO DEC OVERLAY HANDLER
	TOVRLA	=1000		;ADDRS AT WHICH OVERLAY HANDLER LOADED
	$OVREL	=3172 - TOVRLA	;RELOCATION CONSTANTS
;	FOR DEC OVERLAY HANDLER ADDRESSES THIS AMOUNT MUST BE 
;	SUBSTRACTED FROM ALL ADDRESSES ON THE LINKER LISTING
;	TO OBTAIN THE ACTUAL ADDRESSES OF THE HANDLER INSERTED
;	WITH THE PROGRAM

	TOVRH	=3172 - $OVREL		;START OF DEC OVERLAY HANDLER
	THROOT	=3254 - $OVREL	;ADDRS OF CONTAING HIGH 
					;LIMIT OF ROOT SEGMENT
	THOVLY	=3260 - $OVREL		;ADDRS CONTAING HIGH
					;LIMIT OF OVERLAYS
	TOVTAB	=3276 - $OVREL		;ADDRS OF OVERLAY TABLE

;	ERROR CHECKING ON ASSEMBLY PARAMETERS

	.IF GT, SGMX-50.
	.ERROR			;NO MORE THAN 50. SEGMENTS ALLOWED
	.ENDC

	.IF LE, SGMX		;THUS NO. OF SEGMENTS SHOULD BE 
	.ERROR			;BETWEEN 1 AND 50.
	.ENDC

	.IF GT, RGMX-10.	;NO MORE THAN 10. REGIONS ALLOWED
	.ERROR
	.ENDC

	.IF LE, RGMX		;THUS NO. OF REGIONS SHOULD BE
	.ERROR
	.ENDC			;BETWEEN 1 AND 10

	.IF GT,	RSMX-16.
	.ERROR			;NO MORE THAN 16. REGION SETS ALLOWED
	.ENDC

	.IF LE, RSMX
	.ERROR			;NO. OF REGION SETS SHOULD BE BETWEEN
	.ENDC			;1 AND 16.


	
;	EQUATES:
	KISAR0	=172340		;KERNEL I SPACE ADDRS REGISTER 0
	SR0	=177572		;KT11 STATUS REGISTER 0

MROI:
	MOV	@#42,R1		;GET STARTING ADDRS
	SUB	#1000,R1	;DIFFERENCE BY SWITCH /B
	MOV	#$OVRLA,R2	;POINTER TO LOCATION
 	MOV	R1,R0
	ADD	#TOVRLA,R0	;MODIFY ADDRS
	MOV	R0,(R2)+	;STORE IT
	MOV	R1,R0
	ADD	#TOVRH,R0	;MODIFY ADDRS
	MOV	R0,(R2)+
	MOV	R1,R0
	ADD	#THROOT,R0
	MOV	R0,(R2)+
	MOV	R1,R0
	ADD	#THOVLY,R0
	MOV	R0,(R2)+
	MOV	R1,R0
	ADD	#TOVTAB,R0
	MOV	R0,(R2)		;FINISH MODIF.  DUE TO /B
	MOV	$OVRLA,R1
	MOV	#137,(R1)+	;REPLACE BY AN INSTRUCTION
	MOV	PC,R0		;JMP 	@#MROSEV
	ADD	#MROSEV-.,R0	;IN THE FIRST INSTRUCTION OF
	MOV	R0,(R1)		;$OVRH
	TST	(R5)+		;SKIP ARGUMENT COUNT
 ;
 	;MAKE SEGTRR TABLE	SEGMENT CORE ADDRS ARE EQUAL IN A
				;REGION
	CLR	R0		;REGION NO. INITIALLY
	MOV	$OVTAB,R1	;$OVTAB POINTER
	CLR	R2		;WILL CONTAIN CORE ADDRS
	MOV	#SEGTRR,R3	;SEGMENT TABLE POINTER
10$:	BIT	(R1),#1		;JMP IF ODD BIT SET
	BNE	DONE
	CMP	R3,#SEGTRR+2*SGMX	;MORE THAN SGMX?
	BHIS	TERSG		;SKIP IF ERROR
	CMP	R0,#2*RGMX	;MORE THAN RGMX?
	BGE	TERRG		;SKIP IF ERROR
	CMP	(R1),R2		;COMPARE CORE ADDRS
	BEQ	20$		;SKIP IF NO CHANGE IN REGION NO.
	ADD	#2,R0		;INCREMENT REGION NO.
	CLRB	(R3)+		;SHOW SEGMENT NOT IN CORE
	MOVB	R0,(R3)+	;WRITE 2*SEGMENT #
	MOV	(R1),R2		;NEW CORE ADDRS
	ADD	#6,R1		;NEW CORE ADDRS POINTER
	BR	10$
20$:	;NO CHANGE CASE IN REGION NO.
	CLRB	(R3)+		;SHOW SEGMENT NOT IN CORE
	MOVB	R0,(R3)+	;WRITE 2*REGION NO.
	ADD	#6,R1		;ADVANCE A NEW CORE ADDRS
	BR	10$
TERSG:	BR	ERRSEG
TERRG:		BR	ERRREG
DONE:	
	;CHECK VALIDITY OF ADDRS $HROOT AND #HOVLY. THEY SHOULD
	;BE A MULTIPLE OF 4K.
	CLR	R0		;PREPARE DIVIDE
	MOV	@$HROOT,R1	;DIVIDE BY 4K
	DIV	#20000,R0	;
	TST	R1		;REMAINDER
	BNE	ERRLNK		;SKIP IF AN ERROR
	MOV	R0,HROOT	;STORE QUOTIENT
	CLR	R0		;PREPARE NEXT DIVIDE
	MOV	@$HOVLY,R1	
	DIV	#20000,R0	;DIVIDE BY 4K
	TST	R1		;REMAINDER
	BNE	ERRLNK		;SKIP IF AN ERROR
	MOV	R0,HOVLY	;QUOTIENT
	SUB	HROOT,R0	;COMPUTE NCPAR
	MOV	R0,NCPAR	;STORE IT
	MOV	@(R5)+,R4	;GET NO. OF K'S OF CORE
	SUB	#28.,R4		;COMPUTE # 0F K'S OF UPPER CORE
	MOV	#4,R3		;GIVEN TO REGION SETS
	MUL	NCPAR,R3	;COMPUTE NO. OF K'S
	MOV	R4,R1		;COPY AMNT OF UPPER CORE
	CLR	R0		;PREPARE FOR DIVIDE
	DIV	R3,R0		;COMPUTE NO. OF REGION SETS
	INC	R0		;PLUS ONE FOR LOWER CORE
	CMP	R0,#RSMX	;MORE THAN RSMX?
	BGT	ERRRS		;SKIP IF SO
	MOV	R0,@(R5)		;STORE IT
	MOV	R0,NRS		;SAVE NUMB OF RS
	;CREATE RSTBA TABLE
	;FIRST DO REGION SET # 1
	MOV	HROOT,R1	;GET PAGE NO. START VIR. OVER. AREA
	ASL	R1		;IN BYTES
	MOV	#KISAR0,FPAR	;FIRST KIPAR IN RS
	ADD	R1,FPAR		;COMPUTED HERE
	MOV	#RSTBA,R3	;POINTER TO TABLE TO BE CREATED
	MOV	HROOT,R1	;GET START PHYS. PAGE NO.
	MUL	#200,R1		;PHYS. BLOCK NO.
	MOV	R1,(R3)+	;WRITE
	DEC	R0		;ONE LESS
	;NOW DO REGION SET # 2 ...AT 28K...
	MOV	#7,R2		;CORRESPOND TO BASE ADDRS AT 28K
20$:	MOV	R2,R1		;COPY
	MUL	#200,R1
	MOV	R1,(R3)+	;WRITE
	ADD	NCPAR,R2
	SOB	R0,20$		;WRITE DONE
	;
	;INITIALIZE MEMORY MANAGEMENT
	;
	JSR	PC,MMINIT
	;
	;CELAR OVERLAY REGIONS
	;
CLOVR:
	CLR	R2
	MOV	NRS,R5		;REGION SET PARAMETER
40$:	ADD	#2,R2		;2*REGION SET #
	JSR	PC,MAPNG
	INC	SR0		;TURN ON KT11
	JSR	PC,CLEAR	;CLEAR ONE REGION SET FOR GIVEN RS
	DEC	SR0		;TURN OFF KT11
	SOB	R5, 40$		;REPEAT RSN TIMES
	RTS	PC
;
	
CLEAR:	MOV	@$HROOT,R1	;START ADDRS OF CLEARING
	MOV	@$HOVLY,R4	; END ADDRS
50$:	CLR	(R1)+
	CMP	R1,R4
	BLO	50$
	RTS	PC
;
ERRLNK:
	MOV	#-1,@2(R5)	;RETURN ERROR CODE IN NRS
	.PRINT	#ERRMSG
	RTS	PC		;RETURN
	.NLIST	BEX
ERRMSG:	.ASCIZ	/OVERLAY BOUNDARY ERROR/
	.EVEN

	.LIST	BEX
ERRSEG:
	MOV	#-2,@2(R5)	;RETURN ERROR CODE IN IN SEG
	.PRINT	#MSGSEG
	RTS	PC
	.NLIST	BEX
MSGSEG:	.ASCIZ	/OVERFLOW SEGMENT NO./
	.EVEN
	.LIST	BEX

ERRREG:
	MOV	#-3,@2(R5)	;RETURN EROR CODE IN REGION NO.
	.PRINT	#MSGREG
	RTS	PC
	.NLIST	BEX
MSGREG:	.ASCIZ	/OVERFLOW REGION NO./
	.EVEN
	.LIST	BEX

ERRRS:
	MOV	#-4,@(R5)
	.PRINT	#MSGRS		;RETURN ERROR CODE IN REGION SET NO.
	RTS	PC
	.NLIST	BEX
MSGRS:	.ASCIZ	/OVERFLOW REGION SET NO./
	.EVEN
	.LIST BEX

	;USAGE OF REGISTERS R0-R5:
	;R0=2*SEGMENT NUMBER
	;R2=REGION SET NUMBER
	;R3=2*REGION NUMBER
	;THE OTHER ONES ARE SCRATCH.
	;(R5=THE ARGUMENT POINTER IS SAVED & RESTORED)
	;
MROSEV:
	CLR	SR0		;TURN OFF KT11
	CLR	-(SP)		;REARRANGE STACK AS FOLLOWS
	CLR	-(SP)		;CURRSN
	MOV	4(SP),(SP)	;#SUBRTN
	MOV	#SUBRTN,2(SP)	;OLD R5
	MOV	CURRSN,4(SP)
	MOV	R4,-(SP)	;SAVE REGISTERS
	MOV	R3,-(SP)
	MOV	R2,-(SP)
	MOV	R1,-(SP)
	MOV	R0,-(SP)
	MOV	(R5)+,R1	;6*SEGMENT #
	CLR	R0
	DIV	#3,R0		;2*SEGMENT #
	MOVB	SEGTRR-1(R0),R3  ;GET 2*REGION #
	MOVB	SEGTRR-2(R0),R2 ;GET REGION SET #
	BEQ	10$		;SKIP IF NON-RESIDENT
	MOV	R2,R4		;COPY REGION SET #
	ASL	R4		;FOR BYTE ADDRESSING
	BIS	RSTLR-2(R4),LRUBT-2(R3)  ;SET DESIRED BIT IN LRU TABLE
	MOV	R2,CURRSN	;STORE
	MOV	R0,CURSEG	;STORE CURRENT SEGMENT NO.
	BR	MAPP		;GO TO MAP
10$:	;NON-RESIDENT CASE
	MOV	R5,-(SP)	;SAVE

	.GLOBL	RSRCH
	JSR	PC,RSRCH	;INPUT:2*REGION # IN R3
				;2*SEG # IN R0
				;OUTPUT:REGION SET # IN R2
				;    2*SEG # IN R0
				;   2*REGION # IN R3
	;NOW LOOK UP RRTSEG AND UPDATE IT
	MOV	R0,CURSEG	;STORE CUREENT 2*SEG #
	MOV	R3,R5		;USE R5 AS SCRATCH
	ASR	R5		;REFERENCE IS TO A BYTE TABLE
	MUL	#RSMX,R5	;COMPUTE OFFSET FROM TABLE
				;START - RSMX TO ENTRIES FOR THIS REGION
	ADD	R2,R5		;OFFSET
	ADD	#RRTSEG-RSMX-1,R5  ;ADD IN ZEROTH ADDRS OF TABLE
	MOVB	(R5),R1		;GET SEGMENT # IN MEMORY
	BNE	20$		;SKIP IF SOME SEGMENT IS THERE
	MOVB	R0,(R5)		;WRITE NEW SEGMENT #*2 IN RRTSEG
	BR	30$
20$:	;SOME SEGMENT ALREADY EXISTS
	MOVB	R0,(R5)		;WRITE 2*SEGMENT IN RRTSEG
	CLRB	SEGTRR-2(R1)	;OLD SEGMENT NO LONGER IN MEMORY
30$:
	MOVB	R2,SEGTRR-2(R0)	;INSERT REGION SET # OF THIS NEW SEG.
	MOV	R2,CURRSN	;STORE CURRENT REGION SET #
	;
	;OVERWRITE
	;
	MOV	(SP)+,R5		;RESTORE
	MOV	-2(R5),R1		;GET 6*SEGMENT #
	ADD	$OVTAB,R1		;POINTER TO DESISRED SEGMENT #
	SUB	#6,R1
	MOV	(R1)+,R4		;CORE ADDRS OF REGION SET
					;RELATIVE TO ADRS 0
	SUB	@$HROOT,R4		;RELA TIVE TO START OF REG SET
	MOV	R1,-(SP)		;SAVE IT TILL READ IN OF REG.
	;
	;CALCULATE 18-BIT PHYSICAL ADDRESS USING CURRSN IN R2
	;
	MOV	R2,R0			;COPY CURRENT RSN
	ASL	R0			;BYTE ADDRESSING
	MOV	RSTBA-2(R0),R0		;PICK UP BASE ADDRS OF REG. SET
	MUL	#100,R0			;BASE ADDRS IN BYTES
					;R0=HIGH ORDER
					;R1=LOW ORDER
	ADD	R4,R1			;ADD AMOUNT TO GET TO REGION START
	ADC	R0			;ADD CARRY INTO HIGH ORDER
	MOV	R0,ODBB			;STORE PHYS. ADDRS
	MOV	R1,ODBB+2
	MOV	(SP)+,R1		;RESTORE
	MOV	(R1)+,BLK		;BLOCK NO.
	MOV	(R1),WCNT		;WORD COUNT
	MOV	#AREA,R0
	EMT	375
	;
	;MAPPING
	;
MAPP:
	.IF NE RS1NMP
     	CMP	#1,R2			;IS RSN EQUAL TO 1?
	BEQ	50$
	.ENDC	;NE RS1NMP
	ASL	R2			;MAKE 2 * REGION SET #
	JSR	PC,MAPNG
	INC	SR0		;TURN ON KT11
50$:
	MOV	@R5,R5			;SET UP ENTRY ADDRS
	MOV	(SP)+,R0		;RESTORE
	MOV	(SP)+,R1
	MOV	(SP)+,R2
	MOV	(SP)+,R3
	MOV	(SP)+,R4
	RTS	R5
	;MAPPING REGION SET
	;INPUT: 2*REGION SET # IN R2
	;	NUMBER OF PAGES IN A REGION SET IN NCPAR
	;	FIRST PAR ADDRS IN FPAR
	;	FIRST BASE ADDRS IN RSTBA
	;OUTPUT: KIPAR'S FROM FPAR,..,TO FPAR+NCPAR-1
	;	ARE SET WITH VALUES TO MAP
MAPNG:
	MOV	#200,R0			;BASE ADDRS INCREMENT
	MOV	RSTBA-2(R2),R4	;BASE ADDRS
	MOV	FPAR,R3			;KIPAR ADDRS
	MOV	NCPAR,R1		;PAGE NO.
20$:	MOV	R4,(R3)+		;MAP IT
	ADD	R0,R4			;INCREMENT
	SOB	R1,20$			;ALL PAGES
	RTS	PC
	;
	;IF RETURN IS MADE, WE USE THE SAVED REGION SET NO. TO PUT
	;THE MAP BACK AND THEN RETURN TO THE SEGMENT SECTION WHICH
	;CALLED THE SEGMENT CURRENTLY MAKING THE RETURN.
	;
SUBRTN:
	CLR	SR0			;TURN OFF KT11
	MOV	(SP)+,PRERSN		;PREVIOUS RSN
	CMP	PRERSN,CURRSN
	BEQ	SKPMAP
	MOV	PRERSN,CURRSN		;MAKE PREVIOUS RSN TO CURRENT
	.IF	NE,RS1NMP
	CMP	#1,CURRSN
	BEQ	EXT
	.ENDC	;NE,RS1NMP
	MOV	R0,-(SP)		;SAVE
	MOV	R1,-(SP)	
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	CURRSN,R2
	ASL	R2			;MAKE 2 * REGION SET #
	JSR	PC,MAPNG		;MAP
	MOV	(SP)+,R4		;RESTORE
	MOV	(SP)+,R3		;R5 ASSUMED NO CHANGE DURING
	MOV	(SP)+,R2		;MAPPING
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	INC	SR0			;TURN ON KT11
	RTS	PC
SKPMAP:
	.IF	NE,RS1NMP		;IF TO MAP REGION SET #1
	CMP	#1,CURRSN
	BEQ	EXT
	.ENDC	;NE RS1NMP
	INC	SR0
EXT:	RTS	PC
	;
	.IF NE, RSLCL
	;REGION SET SEARCH ROUTINE
	;SCAN REGION SET BIT TABLE (LRUBT) TO FIND A REGION SET #
	;WHERE WE CAN OVERWRITE.
	;INPUT: 2*REGION # IN R3
	;	2*SEG # IN R0
	;OUTPUT:REGION SET # IN R2
	;	2*.SEG # IN R0
	;
	;APPLICATION TO RTMULTI VER 3
	;BASIC MULTI OVERLAYS ARE LOADED IN THE LOWER CORE AREA.
	;NEW OVERLAYS ARE LOADED IN THE UPPER CORE AREA.
	;
RSRCH:
	MOV	R0,-(SP)		;SAVE
	MOV	R3,-(SP)		;SAVE
	ADD	#LRUBT-2,R3		;COMPUTE BIT WORD FOR REGION #
	MOV	#URST,R1
4$:	CMP	R0,(R1)		;2*SEG # GIVEN, 2*SEG # IN TABLE
	BNE	5$		;JUMP IF DISAGREE
	BR	1$
5$:	TST	(R1)+		;END OF TABLE RSEG?
	BNE	4$		;NEXT SEG # IF NOT
	MOV	#1,R2		;REG SET # 1
	BR	6$
1$:	MOV	NRS,R1			;NO. OF REGION SET
	MOV	#1,R4			;FIRST BIT CORES. TO RSN 1
	MOV	R4,R2			;RSN IDENTIFIER
2$:	BIT	(R3),R4			;IS REGION SET RECENTLY USED?
	BEQ	3$			;SKIP IF HASN'T BEEN
	BIC	R4,(R3)			;RESET SO WE CAN TELL 
					;IF USED IN BETWEEN NOW & NEXT
	INC	R2			;POSSIBLE RSN TO DESIRE
	ASL	R4			;MOVE UP TEST BIT
	SOB	R1,2$
	BR	1$
3$:	;FOUND A NOT-RECENTLY-USED REGION SET
	BIS	R4,(R3)			;SHOW WE ARE GOING TO USE
6$:
	MOV	(SP)+,R3
	MOV	(SP)+,R0		;RESTORE
	RTS	PC
	.ENDC	;NE, RSLCL
	;
;	OVERLAY PARAMETERS

	.CSECT	MROPAR
NRS:	.WORD	0		;NO.OF REGION SET SETUP
$OVRLA:	.WORD	0
$OVRH:	.WORD	0
$HROOT:	.WORD	0
$HOVLY:	.WORD	0
$OVTAB:	.WORD	0
;
HROOT:	.WORD	0		;PAGE NO. OF START OF VIRTUAL
				;OVERLAY AREA
HOVLY:	.WORD	0		;PAGE  NO. OF START OF FREE AREA,
				;DRIVER, MONITOR
NCPAR:	.WORD	0		;NO. OF PAGES IN REGION SET
CURRSN:	.WORD	1		;CURRENT REGION SET NO.
FPAR:	.WORD	0		;FIRST KIPAR # IN REGION SET
ODBB:	.WORD	0,0		;18-BIT PHYS. ADDRS IN ODD ADDRESSING
PRERSN:	.WORD	0		;PREVIOUS RSN
AREA:
CHNL:	.BYTE	17
	.BYTE	10
BLK:	.WORD	0
BUF:	.WORD	ODBB!1
WCNT:	.WORD	0,0
;
;	OVERLAY SERVICE TABLES
;
;	SEGMENT TO REGION/REGION SET TABLE
	;INPUT:SEGMENT #
	;OUTPUT:REGION # AND REGION SET # IF IN CORE
SEGTRR:	
	.REPT	SGMX
	.BYTE	0,0		;REGION SET NO., AND REGION # * 2
	.ENDR
;
;	LEAST-RECENTLY-USED BIT TABLE
;	INPUT:REGION #, AND REGION SET #
;	OUTPUT:REGION SET # WHERE A NEW SEGMENT IS OVERWRITTEN
;
LRUBT:
	.REPT	RGMX
	.WORD	0		;BIT INFORMATION FOR REGION SET #
	.ENDR
;
;	REGION/REGION SET TO SEGMENT TABLE
;	INPUT:REGION # AND REGION SET #
;	OUTPUT:SEGMENT # OCCUPYING REGION/REGION SET
;
RRTSEG:
	.REPT	RGMX
	.REPT	RSMX
	.BYTE	0
	.ENDR
	.ENDR
;
;	SUBSIDIARY TABLE
;
;	REGION SET TO LRU BIT
;	INPUT: REGION SET #
;	OUTPUT: LRU BIT
RSTLR:
	$NO=1
	.REPT	RSMX
	.WORD	$NO
	$NO=2*$NO
	.ENDR
;
;	REGION SET TO BASE ADDRESS TABLE FOR MAPPING 
;	INPUT: REGION SET #
;	OUTPUT: BASE ADDRESSES IN BLOCK FOR FIRST PAR
;
RSTBA:
	.REPT	RSMX
	.WORD	0	;BASE ADDRS
	.ENDR
	;
	;

	.CSECT	PERSEG
CURSEG:	.WORD	0	;CURRENT SEGMENT NO.
	;SEGMENT NOS. TO BE LOADED IN THE UPPER CORE
	;USER PREPARE AND THEY ARE STORED IN 2* SEG #
URST:
	.REPT	NSGUMX
	.WORD	0
	.ENDR
	.END