.TITLE	MBDPRG	;MBD EXECUTIVE PROGRAM
	.IDENT	'V001M'
;
; THIS MODULE CONTAINS AN MBD LOAD IMAGE OF AN MBD EXECUTIVE WHICH
; INTERFACES WITH THE RSX-11D MBD HANDLER TASK.  IT CONSISTS OF AN
; INITIALIZATION ROUTINE AND DISPATCHER, PLUS A LARGE NUMBER OF
; SPECIFIC FUNCTION ROUTINES.  IT ALLOWS VARIOUS MBD CONTROL OPERATIONS
; AND CAMAC TRANSACTIONS TO BE EXECUTED BY SPECIFYING A NUMERIC FUNCTION
; CODE AND ANY NECESSARY ARGUMENTS (SUCH AS FCNA'S).  A SEQUENCE OF SUCH
; REQUESTS IS EXECUTED BY A PARTICULAR MBD CHANNEL AND IS CALLED A 
; CHANNEL PROGRAM.  CHANNEL PROGRAMS MAY BE EXECUTED EITHER FROM MBD 
; MEMORY OR FROM PDP MEMORY, ALTHOUGH IN THE LATTER CASE NOT ALL 
; FUNCTIONS ARE IMPLEMENTED.
;
; EACH MBD CHANNEL HAS ASSOCIATED WITH IT A NORMAL ENTRY AND AN ABORT
; ENTRY INTO AN MBD-RESIDENT CHANNEL PROGRAM.  AN IO.RLB FUNCTION CODE
; REQUEST TO THE RSX MBD HANDLER CAUSES THE CHANNEL PROGRAM TO BE 
; ENTERED AT ITS NORMAL ENTRY; THE CHANNEL PROGRAM TYPICALLY CLEARS
; MODULES, ENABLES LAMS, WAITS FOR A LAM, READS OUT DATA TO THE PDP 
; BUFFER SPECIFIED IN THE QIO DIRECTIVE, AND FINALLY DISABLES LAMS AND
; STOPS.  AN IO.KIL FUNCTION CODE REQUEST TO THE RSX MBD HANDLER CAUSES 
; THE CHANNEL PROGRAM TO BE ENTERED AT ITS ABORT ENTRY, WHICH TYPICALLY
; DISABLES LAMS AND STOPS.  AN MBD-RESIDENT CHANNEL PROGRAM CAN CAUSE A
; PDP-RESIDENT CHANNEL PROGRAM TO BE EXECUTED BY A CM.EXP INSTRUCTION;
; THE PDP CHANNEL PROGRAM CAN LATER RETURN CONTROL TO THE MBD PROGRAM
; BY A CM.EXM INSTRUCTION.  SINCE A PDP-RESIDENT CHANNEL PROGRAM IS IN 
; THE BUFFER SPECIFIED BY THE QIO, AND SINCE THIS SAME BUFFER IS ALSO
; USED BY SOME INSTRUCTIONS (E.G., CAMAC READS) AS A DESTINATION FOR
; CAMAC OR MBD DATA, THE RIGHT NUMBER OF WORDS MUST BE INSERTED BETWEEN
; SUCH INSTRUCTIONS TO ALLOW STORING THE DATA (I.E., AS IN THE PDP-11
; INSTRUCTION  MOV X,#0 ).  INSTRUCTIONS WHICH TRANSFER A VARIABLE 
; AMOUNT OF DATA (E.G., CAMAC READS IN Q-STOP BLOCK TRANSFER MODE) ARE
; THUS FORBIDDEN TO PDP-RESIDENT CHANNEL PROGRAMS.  SINCE THE PDP 
; CHANNEL PROGRAMS ARE LIKE SUBROUTINES CALLED BY AN MBD PROGRAM VIA THE
; CM.EXP INSTRUCTION (WHICH HAS NO ARGUMENTS), INSTRUCTIONS WHICH TAKE 
; MBD ARGUMENTS (E.G., WRITE MBD TO CAMAC) ARE ALSO FORBIDDEN TO 
; PDP-RESIDENT PROGRAMS (ALL ARGUMENTS MUST COME FROM THE PDP BUFFER).
;
; THE MBD DISPATCHER AND FUNCTION ROUTINES CAN DETECT VARIOUS SOFTWARE
; AND HARDWARE ERROR CONDITIONS.  CHANNEL PROGRAMS CAN SPECIFY THAT
; CONTROL BE TRANSFERRED TO A PARTICULAR POINT WHEN AN ERROR OCCURS BY
; EXECUTING A CM.JPE INSTRUCTION (JUMP ON ERROR).  SINCE A PDP CHANNEL
; PROGRAM IS CALLED FROM AN MBD CHANNEL PROGRAM, BOTH A PDP AND AN MBD
; ERROR EXIT ADDRESS CAN EXIST.  IF BOTH HAVE BEEN SPECIFIED, THE
; PDP ERROR EXIT TAKES PRECEDENCE.  WHEN AN ERROR OCCURS, A COMPLETION 
; CODE AND ERROR INFORMATION WORD ARE STORED (PROVIDING INFORMATION 
; ABOUT THE ERROR); IF A PDP ERROR EXIT EXISTS, CONTROL TRANSFERS TO 
; THAT ADDRESS IN THE PDP BUFFER; IF NOT, AND AN MBD ERROR EXIT EXISTS,
; CONTROL TRANSFERS TO THAT MBD ADDRESS.  IF NEITHER EXIST, A CM.STP 
; INSTRUCTION IS EXECUTED, STOPPING THE CHANNEL.  WHEN A CHANNEL STOPS,
; THE MBD EXECUTIVE WRITES THE STORED COMPLETION CODE INTO THE SECOND
; WORD OF THE BUFFER HEADER; IF IT IS NEGATIVE (INDICATING A FATAL ERROR
; OCCURED), THE STORED ERROR INFORMATION WORD IS WRITTEN INTO THE FIRST
; WORD OF THE BUFFER HEADER, BUT IF POSITIVE, THE COUNT OF WORDS
; TRANSFERRED TO/FROM THE PDP IS WRITTEN INTO THE FIRST BUFFER HEADER 
; WORD.  THE RSX MBD HANDLER THEN RETURNS THIS INFORMATION TO THE 2 WORD
; I/O STATUS BLOCK SPECIFIED IN THE QIO: THE COMPLETION CODE TO THE LOW
; BYTE OF THE FIRST WORD, AND TWICE THE WORD COUNT, OR ERROR INFORMATION
; WORD, TO THE SECOND WORD.
;

; THE CHANNEL INSTRUCTIONS IMPLEMENTED BY FUNCTION ROUTINES PROVIDE 
; FACILITIES FOR STOPPING A CHANNEL (WRITING THE BUFFER HEADER, 
; INTERRUPTING THE PDP-11, AND EXITING), CHANGING THE NORMAL ENTRY
; POINT, INTERRUPTING THE PDP, WRITING OUT THE CURRENT WORD COUNT, 
; SIGNALLING A USER-DEFINED ERROR, WAITING FOR LAMS, UNCONDITIONAL 
; BRANCHING, LOADING A LOOP COUNT, DECREMENTING A LOOP COUNT AND
; BRANCHING IF NON-ZERO, TESTING THE LOOP COUNT AFTER "ANDING" WITH MASK
; AND BRANCHING IF ZERO OR NON-ZERO, MOVING THE PDP BUFFER POINTER, 
; CONDITIONAL BRANCHING ON Q OR X FROM A CAMAC CONTROL FCNA, SETTING AN 
; ERROR EXIT, REMOVING ALL MBD-RESIDENT CHANNELS, LOADING A CHANNEL 
; PROGRAM INTO THE MBD, EXAMINING & DEPOSITING MBD MEMORY, SENDING WORDS
; TO THE PDP BUFFER, DOING CAMAC "BZ" AND CONTROL OPERATIONS, MBD TO
; CAMAC WRITE, PDP TO CAMAC WRITE, IMMEDIATE TO CAMAC WRITE, CAMAC TO PDP
; READ, AND EXECUTING A MANUAL FUNCTION FROM A TEST MODULE (SUCH AS A 
; TM024) WITH SWITCHES AND INDICATOR LIGHTS (FUCTIONS ARE: EXAMINE OR 
; DEPOSIT MBD MEMORY; CAMAC CONTROL; CAMAC READ OR WRITE; AND MANUAL
; ERROR SIGNALLING).  MOST CAMAC READ AND WRITE FUNCTIONS SUPPORT BLOCK 
; TRANSFERS IN Q-STOP MODE, Q-REPEAT MODE, AND THE NORMAL FCNA-LIST MODE.
; IN ADDITION, SPECIAL FUNCTION ROUTINES HAVE BEEN ADDED FOR SYSTEM-
; SPECIFIC FUNCTIONS: READING OUT HODOSCOPE TDC'S, READING OUT LECROY
; 2770 DRIFT CHAMBER MODULES, MAKING TOF CUTS ON HODOSCOPE TDC DATA,
; PERFORMING PHI-MATCHING OF HODOSCOPE TDC DATA, WRITING EVENTS
; INTO A FIFO CAMAC MEMORY FOR TRANSMISSION TO ANOTHER COMPUTER SYSTEM,
; AND TESTING THE NO. OF WORDS IN THE BUFFER TO REJECT EVENTS WHICH
; ARE TOO SHORT.
;
; CHANNEL 7 OF THE MBD (THE HIGHEST PRIORITY CHANNEL) IS RESERVED
; FOR USE AS A "CONTROL" CHANNEL, WHICH CAN EXECUTE PDP-RESIDENT CHANNEL
; PROGRAMS, INCLUDING PROGRAMS TO LOAD OTHER MBD CHANNELS.
;
; THE MBD EXECUTIVE USES THE FOLLOWING FILE REGISTERS, WHICH CANNOT BE
; USED FOR OTHER PURPOSES BY FUNCTION ROUTINES:
; BANK 0 ILR: MBD PROGRAM'S "PROGRAM COUNTER": USED TO FETCH MBD DATA
; BANK 0 DAR: PDP BUFFER POINTER AND PDP PROGRAM'S "PROGRAM COUNTER"
; BANK 1 ILR: PDP ERROR EXIT ADDRESS: PDP ADDRESS TO BRANCH TO ON ERROR
; BANK 1 CTR: MBD ERROR EXIT ADDRESS: MBD ADDRESS TO BRANCH TO ON ERROR
; BANK 1 DAR: STARTING PDR VALUE PLUS ONE: ZERO IF CHANNEL DOING ABORT 
;	      REQUEST; ELSE SPECIFIES THE ADDRESS OF THE SECOND WORD OF
;	      THE PDP BUFFER HEADER (THE BUFFER ITSELF BEGINS WITH THE
;	      NEXT WORD).
; BANK 1 WCR: THE ADDRESS OF THE LAST WORD IN THE PDP BUFFER
; BANK 1 GP1: THE CHANNEL COMPLETION CODE (INITIALLY IS.SUC = +1)
; BANK 1 CCR: THE CHANNEL ERROR INFORMATION WORD (SET BY ERROR TRAPS)
; BANK 1 GP2: THE CHANNEL LOOP COUNT (FOR CM.LCO & CM.DCB INSTRUCTIONS)
; THE BANK 0 WCR AND CTR CONTAIN (IN BITS 12-15) ON ENTRY TO A FUNCTION
; ROUTINE, BITS 12-15 OF THE CHANNEL INSTRUCTION BEING EXECUTED; THESE
; BITS MAY BE TESTED BY C12 - C15 CONDITION TESTS.  BITS 0-11 OF THE CTR
; ARE THE FUNCTION ROUTINE ADDRESS.  THESE REGISTERS AND BANK 0 CCR,
; GP1, AND GP2 CAN BE USED BY FUNCTION ROUTINES FOR ANY PURPOSE.  THE
; BANK 0 CCR IS COPIED INTO THE BANK 1 CCR WHEN AN ERROR TRAP OCCURS
; (I.E., THE ERROR INFORMATION WORD); IT CONTAINS THE FCNA BEING 
; EXECUTED IN THE CASE OF A CAMAC FUNCTION ROUTINE.
; 

; DEFINITIONS:
NCHAN	=	7.		;NO. OF MBD CHANNELS (BESIDES NO. 7)
NWIRS	=	96.		;NO. OF WIRES IN LECROY 2770 MODULES
MBDMEM	=	2048.		;MBD MEMORY SIZE (SET BEFORE LOADING)
TDCMAX	=	362.		;MAXIMUM VALID TDC VALUE
TDCMIN	=	150.		;MINIMUM VALID TDC VALUE
NHALF	=	12.		;NO. OF COUNTERS FOR 180 DEGREES
NRANG	=	7		;RANGE WITHIN SECOND TRACK MUST BE
TDCDMX	=	512.		;MAXIMUM VALID TDC VALUE (FOR TOF CUT)
; 
; MACRO CALLS (DCPMAC):
; 
	.MCALL	MBD2PG
	MBD2PG			;DEFINE MBD INSTRUCTIONS
;
; READ-WRITE DATA PROGRAM SECTION
	.PSECT MBDPRW,D
MBDPGM::.WORD	0		;STARTING MBD ADDRESS
	.WORD	MBDEND		;NO. OF WORDS IN MBD LOAD IMAGE
	JVC			;***CHANNEL ENTRY: JUMP VIA THE CTR***
	INM	PDR,DAR		;PDP CHANNEL INITIATE: GET BUFFER HDR+1
	CON	BK1		;SELECT BANK 1
	DEP	DAR		;SAVE IT IN BANK 1 DAR
	MV	0,WCR		;CLEAR BANK 1 WCR (LAST BUFFER LOCATION)
	CON	BK0		;SELECT BANK 0
	LCI	DSPTCH		;ADDRESS OF CHANNEL DISPATCH TABLE
	AD	CCL,ATR		;ADD 2 * CHANNEL NO. (2 WORDS PER CHAN)
	AD	CCL,CTR		;PUT RESULT IN CTR
	MV	DAR,ATR		;GET BUFFER HEADER ADDRESS PLUS ONE
	BCT	START,ZF	;IF ZERO, GO TO ABORT ENTRY OF CHANNEL
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	DEP	MAR		;PUT IT IN MAR
	DEM	MAR,MAR,RDR	;GET FIRST WORD OF BUFFER HDR=WORD COUNT
	BCT	$,DCB		;WAIT FOR WORD TO ARRIVE
	INM	MAR,ATR,BK1	;ADDR. OF WORD BEFORE BUFFER
	AD	MDR,WCR		;ADD WORD COUNT GIVING LAST BUFFER ADDR.
	CON	BK0		;SELECT BANK 0
	INM	CTR,CTR		;BUMP CTR TO NORMAL ENTRY OF CHANNEL
START	=	$		;***INITIALIZE CHANNEL REGISTERS***
	DEM	MEM,ILR		;BANK 0 ILR=ADDR. OF FIRST CHAN INSTR.-1
	CON	BK1		;SELECT BANK 1
	INM	0,GP1		;BANK 1 GP1=+1 (COMPLETION CODE=IS.SUC)
	INM	0,GP2		;BANK 1 GP2=1 (LOOP COUNT)
	MV	0,CCR		;BANK 1 CCR=0 (ERROR INFORMATION WORD)
NOJER	=	$		;***SET PDP & MBD ERROR EXIT ADDRESS***
	DEP	ILR		;BANK 1 ILR=PDP ERROR EXIT (0->NONE)
	CON	BK1		;SELECT BANK 1
	MV	0,CTR		;BANK 1 CTR=MBD ERROR EXIT (0->NONE)
CONTN0	=	$		;***SELECT BANK 0 & CONTINUE***
	CON	BK0		;SELECT BANK 0
CONTIN	=	$		;***GET NEXT CHANNEL ADDRESS***
	INM	ILR,CTR		;INCREMENT MBD CHAN PGM ADDR, PUT IN CTR
FETCH	=	$		;***FETCH NEXT CHANNEL INSTRUCTION***
	MV	MEM,WCR		;GET OPCODE & FLAG BITS (15-12) INTO WCR
	LCI	7777		;MASK FOR BITS 11-0
	AND	WCR,CCR		;MASK OUT OPCODE, SAVE IN CCR
	SB	WCR,WCR		;REMAINDER=FLAG BITS, SAVE IN WCR
	LCI	NFCMBD		;NUMBER OF MBD FUNCTIONS
	SB	CCR,ATR		;COMPARE WITH OPCODE
	BCT	INVLID,CF	;IF OPCODE GREATER OR EQUAL, INVALID
	LCI	MBDFUN		;ADDR. OF MBD FUNCTION DISPATCH TABLE
GOEXEC	=	$		;***BRANCH TO NEXT FUNCTION ROUTINE***
	AD	CCR,CTR		;ADD OPCODE TO GET DISPATCH TABLE ADDR.
	MV	MEM,ATR		;GET FUNCTION ROUTINE ADDRESS
	IOR	WCR,CTR,EX1	;COMBINE WITH FLAG BITS (15-12) & EXIT 1

EXECP	=	$		;***FUNCTION: EXECUTE PDP CHAN PGM***
	DEM	ILR,ILR		;DECREMENT MBD ADDR (STAY ON THIS INSTR)
	LCI	$+2		;RETURN POINT
	JP	READ		;READ A WORD FROM PDP BUFFER
	MV	MDR,WCR		;GET OPCODE & FLAG BITS (15-12) INTO WCR
	LCI	7777		;MASK FOR BITS 11-0
	AND	WCR,CCR		;MASK OUT OPCODE, SAVE IN CCR
	SB	WCR,WCR		;REMAINDER = FLAG BITS, SAVE IN WCR
	LCI	NFCPDP		;NO. OF PDP FUNCTIONS
	SB	CCR,ATR		;COMPARE WITH OPCODE
	BCT	INVLID,CF	;IF OPCODE GREATER OR EQUAL, INVALID
	LCI	PDPFUN		;ADDR. OF PDP FUNCTION DISPATCH TABLE
	JP	GOEXEC		;GO TO FUNCTION ROUTINE
INVLID	=	$		;***INVALID CHANNEL OPCODE***
	LD	INVER		;INVALID FUNCTION ERROR CODE
	JP	ERRX		;DECLARE ERROR
EXECM	=	$		;***FUNCTION: RETURN TO MBD CHAN PGM***
	INM	ILR,ILR		;SKIP PAST "EXECP" INSTRUCTION
	CON	BK1		;SELECT BANK 1
	MV	0,ILR		;REMOVE PDP ERROR EXIT
	JP	CONTN0		;DONE
RESTRT	=	$		;***FUNCTION: STOP CHAN,SET RSTRT ADR***
	LCI	DSPTCH+1	;DISPATCH TABLE FIRST CHAN NORMAL ENTRY
	AD	CCL,ATR		;ADD TWICE CHANNEL NUMBER...
	AD	CCL,CTR		;...GIVING THIS CHANNEL NORMAL ENTRY
	INM	ILR,MEM		;CHANGE IT TO THIS WORD + 1 (NEXT INSTR)
STOP	=	$		;***FUNCTION: STOP CHANNEL, INTERRUPT***
	LCI	EXIT		;ADDRESS OF EXIT FUNCTION
	CON	BK1		;SELECT BANK 1
	MV	DAR,ATR		;GET BANK 1 DAR=BUFFER HDR ADDR PLUS 1
	CON	BK0		;SELECT BANK 0
	BCT	KILL,ZF		;IF ZERO (DOING ABORT REQUEST) JUST EXIT
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	DEP	MAR,BK1		;ADDR 2ND WORD OF HDR (COMPLETION CODE)
	MV	GP1,MDR,WTH	;WRITE OUT COMPLETION CODE=BANK 1 GP1
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	BCT	FATAL,NF	;NEGATIVE CODE=FATAL ERROR
	MV	MAR,ATR,BK0	;POSITIVE=SUCCESS: GET BUFFER ADDR - 1
	SB	DAR,MDR		;SUBTRACT FROM LAST WORD USED=WORD COUNT
	JP	WRITWC		;GO WRITE IT OUT
FATAL	=	$		;***FATAL ERROR: SEND ERROR INFO WORD***
	MV	CCR,MDR		;GET ERROR INFORMATION WORD=BANK 1 CCR
	CON	BK0		;SELECT BANK 0
WRITWC	=	$		;***WRITE WORD COUNT OR ERROR INFO***
	DEM	MAR,MAR,WTR	;WRITE INTO FIRST WORD OF HEADER
	BCT	$,DCB		;WAIT FOR UNIBUS TO FINISH
EXIT	=	$		;***FUNCTION: INTERRUPT PDP & EXIT***
	BCT	XIT1,INB	;WAIT INTERRUPT UNBUSY (CTR POINTS HERE)
	CON	INT		;INTERRUPT PDP-11 TO SIGNAL CHANNEL DONE
KILL	=	$		;***KILL CHANNEL***
	CON	EX4		;EXIT FOREVER (OR UNTIL PDP RESTARTS)
XIT1	=	$		;***EXIT TEMPORARILY (DO OTHER CHANS)***
	CON	EX1		;EXIT BUT COME RIGHT BACK
INTR	=	$		;***FUNCTION: INTERRUPT PDP-11***
	BCT	XIT1,INB	;WAIT INTERRUPT UNBUSY (CTR POINTS HERE)
	MV	0,DAR		;SET BANK 0 DAR TO ZERO LIKE CHAN ABORT
	CON	BK1		;SELECT BANK 1
	MV	0,DAR		;BANK 1 DAR TOO (TO PREVENT UNIBUS XFRS)
	MV	0,WCR,INT	;CLEAR BANK 1 WCR (LAST BUFFER LOCATION)
				;AND INTERRUPT PDP-11
	JP	CONTN0		;DONE
WCSEND	=	$		;***FUNCTION: SEND WRD CNT TO PDP BUF***
	CON	BK1		;SELECT BANK 1
	MV	DAR,ATR		;GET BANK 1 DAR=BUFFER HDR ADDR PLUS 1
	CON	BK0		;SELECT BANK 0
	BCT	CONTIN,ZF	;IGNORE REQUEST IF DOING AN ABORT FUNCT
	DEP	WCR		;SAVE ADDR OF FIRST BUFFER WORD MINUS 1
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	SB	DAR,MDR		;SUBTRACT FROM LAST WORD USED=WORD COUNT
	INM	WCR,MAR,WTR	;WRITE IT INTO FIRST BUFFER WORD
	JP	CONTIN		;DONE

MERROR	=	$		;***FUNCTION: ERROR TRAP FROM MBD PGM***
	INM	ILR,CTR		;GET NEXT WORD IN MBD
	MV	MEM,CCR		;PUT IT IN CCR (ERROR INFORMATION WORD)
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,ATR		;(COMPLETION CODE)
	JP	ERRX		;DECLARE ERROR
PERROR	=	$		;***FUNCTION: ERROR TRAP FROM PDP PGM***
	LCI	$+2		;RETURN POINT
	JP	READH		;READ A WORD FROM PDP (& HOLD UNIBUS)
	MV	MDR,CCR		;PUT IT IN CCR (ERROR INFORMATION WORD)
	LCI	$+2		;RETURN POINT
	JP	READ		;READ NEXT PDP WORD
	MV	MDR,ATR		;(COMPLETION CODE)
ERRX	=	$		;***COMMON ERROR EXIT POINT***
	CON	BK1		;SELECT BANK 1
	DEP	GP1		;PUT COMPLETION CODE INTO BANK 1 GP1
	CON	BK0		;SELECT BANK 0
	MV	CCR,ATR		;GET ERROR INFORMATION WORD
	CON	BK1		;SELECT BANK 1
	DEP	CCR		;PUT IT INTO BANK 1 CCR
	MV	ILR,ATR		;GET BANK 1 ILR = PDP ERROR EXIT ADDRESS
	BCT	NOPDP,ZF	;IF ZERO, NO PDP ERROR EXIT
	CON	BK0		;ELSE SELECT BANK 0
	DEP	DAR		;SET BUFFER ADDRESS TO ERROR EXIT POINT
	CON	BK1		;SELECT BANK 1
	MV	0,ILR		;CLEAR BK1 ILR=PDP ERROR EXIT (NO LOOPS)
	CON	BK0		;SELECT BANK 0
	JP	LDDAR		;NOW CHECK FOR WITHIN BUFFER
NOPDP	=	$		;***NO PDP ERROR EXIT, TAKE MBD EXIT***
	MV	CTR,ATR		;GET BANK 1 CTR=MBD ERROR EXIT ADDRESS
	CON	BK0		;SELECT BANK 0
	BCT	STOP,ZF		;IF ZERO, NO MBD ERROR EXIT: JUST STOP
	JP	NOJER		;ELSE PUT INTO MBD CHANNEL ADDRESS (ILR)
PAUSE	=	$		;***FUNCTION: WAIT FOR CHANNEL LAM***
	LCI	CONTIN		;RETURN POINT: GET NEXT INSTRUCTION
	CON	EX2		;EXIT AND COME BACK WHEN LAM OCCURS
MNEXT	=	$		;***FUNCTION: DECR CNT & BR IF NON-0***
	CON	BK1		;SELECT BANK 1
	DEM	GP2,GP2		;DECREMENT BANK 1 GP2=LOOP COUNTER
	CON	BK0		;SELECT BANK 0
	BCT	SKIP,ZF		;IF ZERO, SKIP PAST BRANCH ADDR & GO ON
MGOTO	=	$		;***FUNCTION: BRANCH TO AN MBD ADDR***
	INM	ILR,CTR		;GET NEXT MBD WORD (BRANCH ADDR. OFFSET)
	AD	MEM,ILR		;ADD TO CURRENT LOCATION AND PUT IN ILR
	JP	CONTIN		;DONE
SKIP	=	$		;***FUNCTION: SKIP WORD IN MBD PGM***
	INM	ILR,ILR		;FORWARD ONE WORD
	JP	CONTIN		;DONE
MMOVE	=	$		;***FUNCTION: MOVE BUF PTR FWD/BKWD***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,ATR		;(AMOUNT TO ADD TO BUFFER PTR: + OR -)
	JP	LDDAR		;GO ADD IT TO DAR
PNEXT	=	$		;***FUNCTION: DECR CNT & BR IF NON-0***
	CON	BK1		;SELECT BANK 1
	DEM	GP2,GP2		;DECREMENT BANK 1 GP2 = LOOP COUNTER
	CON	BK0		;SELECT BANK 0
	BCT	ADVNCE,ZF	;IF ZERO, SKIP PAST BRANCH ADDR & GO ON

PGOTO	=	$		;***FUNCTION: BRANCH TO PDP LOCATION***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,ATR		;(BRANCH ADDRESS OFFSET)
LDDAR	=	$		;***ADD TO CURRENT BUF ADDR & CHECK***
	AD	DAR,CCR		;ADD TO DAR & PUT IN CCR (NEW BUF ADDR)
	CON	BK1		;SELECT BANK 1
	MV	DAR,ATR		;GET BANK 1 DAR=BUFFER HDR ADDR + 1
	CON	BK0		;SELECT BANK 0
	SB	CCR,ATR		;COMPARE WITH NEW BUFFER ADDR
	BCF	OUT,CF		;IF GREATER THAN, NEW ADDR TOO SMALL
	CON	BK1		;SELECT BANK 1
	MV	WCR,ATR		;GET BANK 1 WCR=LAST BUFFER ADDRESS
	CON	BK0		;SELECT BANK 0
	SB	CCR,ATR		;COMPARE WITH NEW BUFFER ADDRESS
	BCT	OUT,CF		;IF LESS THAN, NEW ADDR TOO BIG
	MV	CCR,DAR		;ELSE PUT IT INTO DAR (NEW BUFFER ADDR)
	JP	CONTIN		;DONE
ADVNCE	=	$		;***FUNCTION: SKIP ONE WORD IN BUFFER***
	INM	DAR,DAR		;ADD ONE TO BUFFER ADDRESS
	JP	CONTIN		;DONE
OUT	=	$		;***BUFFER ADDRESS OUT OF RANGE***
	LD	OUTER		;OUT OF BUFFER LIMITS ERROR
	JP	ERRX		;DECLARE ERROR
MBRNCH	=	$		;***FUNCTION: CONDITIONAL BRNCH (MBD)***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (CAMAC CONTROL FCNA)
	MV	WCR,CTR		;GET FLAG BITS (15-12)
	LCI	$+2		;RETURN POINT
	JP	CNTL		;DO CAMAC CONTROL FUNCTION TO SET X & Q
	BCT	MXTST,C14	;BRANCH ON X IF C14 ON
	BCT	MTRUE,QF	;BRANCH ON Q
MFALSE	=	$		;***CONDITION (X OR Q) IS FALSE***
	BCF	MGOTO,C15	;BRANCH ON CONDITION FALSE IF C15 OFF
	JP	SKIP		;DON'T BRANCH: SKIP PAST BRANCH ADDRESS
MXTST	=	$		;***TEST X BIT***
	BCF	MFALSE,XF	;CONDITION IS FALSE IF X IS OFF
MTRUE	=	$		;***CONDITION (X OR Q) IS TRUE***
	BCT	MGOTO,C15	;BRANCH ON CONDITION TRUE IF C15 IS ON
	JP	SKIP		;DON'T BRANCH: SKIP PAST BRANCH ADDRESS
PBRNCH	=	$		;***FUNCTION: CONDITIONAL BRNCH (PDP)***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;PUT IT IN CCR (CAMAC CONTROL FCNA)
	LCI	$+2		;RETURN POINT
	JP	CNTL		;DO CAMAC CONTROL OPERATION TO SET X & Q
	BCT	PXTST,C14	;BRANCH ON X IF C14 ON
	BCT	PTRUE,QF	;BRANCH ON Q
PFALSE	=	$		;***CONDITION (X OR Q) IS FALSE***
	BCF	PGOTO,C15	;BRANCH ON CONDITION FALSE IF C15 IS OFF
	JP	ADVNCE		;DON'T BRANCH: SKIP PAST BRANCH ADDRESS
PXTST	=	$		;***TEST X BIT***
	BCF	PFALSE,XF	;CONDITION IS FALSE IF X IS OFF
PTRUE	=	$		;***CONDITION (X OR Q) IS TRUE***
	BCT	PGOTO,C15	;BRANCH ON CONDITION TRUE IF C15 IS ON
	JP	ADVNCE		;DON'T BRANCH: SKIP PAST BRANCH ADDRESS
MBITST	=	$		;***FUNCTION: BIT TEST (MBD)***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,BDL		;SAVE IT IN BDL (MASK WORD)
	MV	WCR,CTR		;GET FLAG BITS (15-12)
	MV	BDL,ATR,BK1	;GET MASK WORD & SELECT BANK 1
	AND	GP2,ATR		;"AND" WITH BANK 1 GP2 = LOOP COUNT
	CON	BK0		;SELECT BANK 0
	BCF	MTRUE,ZF	;IF NON-ZERO, CONDITION IS TRUE
	JP	MFALSE		;ELSE IT IS FALSE
PBITST	=	$		;***FUNCTION: BIT TEST (PDP)***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,ATR,BK1	;PUT IT IN ATR (MASK WORD) & SELECT BK1
	AND	GP2,ATR		;"AND" WITH BANK 1 GP2 = LOOP COUNT
	CON	BK0		;SELECT BANK 0
	BCF	PTRUE,ZF	;IF NON-ZERO, CONDITION IS TRUE
	JP	PFALSE		;ELSE IT IS FALSE

MLOOP	=	$		;***FUNCTION: LOAD LOOP COUNT (MBD)***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,ATR		;(LOOP COUNT)
	JP	LDCNT		;GO LOAD IT
PLOOP	=	$		;***FUNCTION: LOAD LOOP COUNT (PDP)***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,ATR		;(LOOP COUNT)
LDCNT	=	$		;***LOAD LOOP COUNTER***
	CON	BK1		;SELECT BANK 1
	DEP	GP2		;PUT IT IN BANK 1 GP2 = LOOP COUNT
	JP	CONTN0		;DONE
MJMPER	=	$		;***FUNCTION: SET MBD ERROR EXIT***
	INM	ILR,CTR		;GET NEXT MBD WORD (OFFSET TO ERR EXIT)
	AD	MEM,ATR		;ADD CURRENT MBD PROGRAM ADDRESS
	CON	BK1		;SELECT BANK 1
	DEP	CTR		;PUT IT IN BANK 1 CTR=MBD ERR EXIT ADDR
	JP	CONTN0		;DONE
PJMPER	=	$		;***FUNCTION: SET PDP ERROR EXIT***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD (OFFSET TO ERR EXIT)
	AD	MDR,ATR,BK1	;ADD CURRENT BUF ADDR (IN ATR FROM READ)
	DEP	ILR		;PUT IT IN BANK 1 ILR=PDP ERR EXIT ADDR
	JP	CONTN0		;DONE
FLUSH	=	$		;***FUNCTION: CLEAR ALL PGMS FROM MBD***
	LCI	2*NCHAN		;2 * NO. OF CHANS (NORMAL & ABORT ENTRY)
	DEP	WCR		;PUT IT IN WCR
	LCI	DSPTCH-1	;ADDR. OF CHANNEL ENTRY POINT TABLE - 1
REMOVE	=	$		;***SET ALL CHAN PGMS TO A STOP INSTR***
	INM	CTR,CTR		;INCREMENT TABLE POINTER
	LD	DFCHAD		;GET ADDRESS OF A "STOP" INSTRUCTION
	DEP	MEM		;PUT IT INTO TABLE
	DEM	WCR,WCR		;COUNT DOWN
	BCF	REMOVE,ZF	;GO UNTIL ALL ARE DONE
	LCI	MBDEND		;ADDR OF FIRST WORD FOLLOWING EXECUTIVE
	ST	CHNADR		;SAVE IT AS PLACE TO LOAD NEXT CHANNEL
	JP	CONTIN		;DONE

BADADR	=	$		;***MBD ADDRESS OUT OF RANGE***
	LD	BADER		;BAD ADDRESS ERROR CODE
	JP	ERRX		;DECLARE ERROR
PLOAD	=	$		;***FUNCTION: LOAD AN MBD CHANNEL PGM***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD (CHANNEL NO. TO LOAD)
	LCI	7		;CHANNEL MASK
	AND	MDR,GP1		;MASK OUT CHANNEL NO. AND SAVE IN GP1
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD (ABORT ENTRY OFFSET)
	MV	MDR,GP2		;SAVE IT IN GP2
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD (LENGTH OF CHAN PGM)
	MV	MDR,WCR		;SAVE IT IN WCR
	LD	CHNADR		;GET NEXT AVAILABLE WORD TO LOAD CHANNEL
	DEP	CCR		;SAVE IT IN CCR
LDLOOP	=	$		;***LOAD PGM FROM BUFFER INTO MBD***
	LD	MBDSIZ		;GET MBD MEMORY SIZE (LAST WORD ADDR+1)
	SB	CCR,ATR		;COMPARE THIS ADDRESS WITH IT
	BCT	BADADR,CF	;IF GREATER OR EQUAL, ERROR
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	CCR,CTR		;PUT MBD ADDRESS INTO CTR
	MV	MDR,MEM		;DEPOSIT DATA IN MEMORY
	INM	CCR,CCR		;NEXT ADDRESS
	DEM	WCR,WCR		;COUNT DOWN
	BCF	LDLOP2,ZF	;DO ALL WORDS
	LCI	DSPTCH+1	;ADDR. OF NORMAL ENTRY OF FIRST CHANNEL
	AD	GP1,ATR		;ADD TWICE CHANNEL NUMBER
	AD	GP1,CTR		;INTO CTR (NORMAL ENTRY OF LOADED CHAN)
	LD	CHNADR		;ADDRESS OF FIRST WORD OF CHANNEL
	DEP	MEM		;STORE IT IN NORMAL CHANNEL ENTRY
	AD	GP2,GP2		;ADD ABORT ENTRY OFFSET GIVING ABS ADDR
	DEM	CTR,CTR		;GO BACK TO ABORT ENTRY WORD
	MV	GP2,MEM		;STORE ABORT ENTRY IN DISPATCH TABLE
	MV	CCR,ATR		;GET LAST ADDRESS LOADED + 1
	ST	CHNADR		;SAVE IT AS LOAD ADDR FOR NEXT CHANNEL
	JP	CONTIN		;DONE
LDLOP2	=	$		;***LOOP OVER ALL WORDS***
	JP	LDLOOP		;DO NEXT WORD
PDEPOS	=	$		;***FUNCTION: DEPOSIT IN MBD MEMORY***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;SAVE IT IN CCR (MBD ADDRESS)
	LD	MBDSIZ		;GET MBD MEMORY SIZE (LAST WORD ADDR+1)
	SB	CCR,ATR		;COMPARE THIS ADDRESS WITH IT
	BCT	BADAD2,CF	;IF GREATER OR EQUAL, ERROR
	LCI	MBDEND		;ADDR OF FIRST WORD FOLLOWING EXECUTIVE
	SB	CCR,ATR		;COMPARE DEPOSIT ADDRESS WITH IT
	BCF	BADAD2,CF	;IF LESS THAN, DON'T ALLOW DEPOSIT
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD (DATA TO DEPOSIT)
	MV	CCR,CTR		;PUT ADDRESS INTO CTR
	MV	MDR,MEM		;DEPOSIT DATA IN MEMORY
CONTN2	=	$		;***GOTO NEXT INSTRUCTION IN CHAN PGM***
	JP	CONTIN		;DONE
BADAD2	=	$		;***BAD MBD ADDRESS ERROR***
	JP	BADADR		;GO SIGNAL ERROR

PEXAM	=	$		;***FUNCTION: EXAMINE MBD MEMORY***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CTR		;PUT IT IN CTR (MBD ADDRESS)
	JP	SNDIT		;SEND WORD AT THAT ADDRESS TO PDP BUF
MSEND	=	$		;***FUNCTION: SEND A WORD TO PDP***
	INM	ILR,CTR		;GET NEXT MBD WORD
SNDIT	=	$		;***SEND WORD TO PDP***
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	MEM,MDR		;PUT WORD INTO MDR
WRTXIT	=	$		;***WRITE A WORD AND QUIT***
	LCI	CONTIN		;RETURN POINT (DONE)
	JP	WRITE		;WRITE OUT THE WORD
INIT	=	$		;***FUNCTION: INITIALIZE CAMAC BRANCH***
	INM	ILR,CTR,BZ	;GET NEXT MBD WORD AND BRANCH INITIALIZE
	BCT	$,BRB		;WAIT FOR BRANCH READY
	JP	FETCH		;GO EXECUTE NEXT FUNCTION
MCNTRL	=	$		;***FUNCTION: EXECUTE CAMAC CTL (MBD)***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;ZERO AT END OF FCNA LIST
	MV	WCR,CTR		;GET FLAG BITS (15-12)
	LCI	MCNTRL		;RETURN POINT (GET NEXT FCNA)
	JP	CNTL		;EXECUTE CAMAC CONTROL OPERATION
PCNTRL	=	$		;***FUNCTION: EXECUTE CAMAC CTL (PDP)***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;ZERO AT END OF FCNA LIST
	LCI	PCNTRL		;RETURN POINT (GET NEXT FCNA)
CNTL	=	$		;***SUB TO EXECUTE CAMAC CONTROL FCNA***
	MV	CCR,BAR,BC1	;EXECUTE CONTROL FCNA
	BCT	$,BRB		;WAIT FOR CAMAC DONE
	BCT	$+2,XF		;SKIP IF X ON
	BCF	NOX,C12		;IF C12 ON, IGNORE NO X ERROR
	BCT	$+2,QF		;SKIP IF Q ON
	BCF	NOQ,C13		;IF C13 ON, IGNORE NO Q ERROR
	JVC			;RETURN

MM2CWT	=	$		;***FUNCTION: MBD WRITE, MBD TO CAMAC***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (FCNA)
	BCT	CONTN2,ZF	;ZERO TERMINATES FCNA LIST
	MV	WCR,CTR		;GET FLAG BITS (15-12)
	BCF	MMC16,C15	;16 BIT WRITE IF C15 OFF, ELSE 24
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,BDH		;(HIGH ORDER DATA)
MMC16	=	$		;***LOAD LOW ORDER DATA***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,BDL		;(LOW ORDER DATA)
	MV	WCR,CTR		;GET FLAG BITS AGAIN (15-12)
	LCI	MM2CWT		;RETURN POINT: NEXT FCNA
CAMRW	=	$		;***SUBROUTINE TO READ/WRITE CAMAC***
	MV	0,GP2		;INITIALIZE REPEAT COUNTER
RWAGN	=	$		;***DO A CAMAC READ OR WRITE***
	MV	CCR,BAR,BC0	;EXECUTE CAMAC FCNA
	BCT	$,BRB		;WAIT FOR DONE
	BCT	$+2,XF		;SKIP IF X ON
	BCF	NOX,C12		;IF C12 ON, IGNORE NO X ERROR
	BCT	$+2,QF		;SKIP IF Q ON
	BCF	QOFF,C13	;IF C13 ON, IGNORE NO Q
	JVC			;RETURN
QOFF	=	$		;***Q OFF AFTER CAMAC READ OR WRITE***
	BCF	NOQ,C14		;IF C14 OFF (NOT REPEAT MODE), THEN ERR
	DEM	GP2,GP2		;ELSE COUNT ANOTHER TRY
	BCF	RWAGN,ZF	;IF NON-0 (NO TIME OUT),REPEAT OPERATION
NOQ	=	$		;***NO Q AFTER CAMAC OPERATION***
	LD	NOQER		;"NO Q" ERROR CODE
	JP	ERRX		;DECLARE ERROR
NOX	=	$		;***NO X AFTER CAMAC OPERATION***
	LD	NOXER		;"NO X" ERROR CODE
	JP	ERRX		;DECLARE ERROR
PM2CWT	=	$		;***FUNCTION: PDP WRITE, MBD TO CAMAC***
	BCF	PMC16,C15	;16 BIT WRITE IF C15 OFF, ELSE 24
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,BDH		;(HIGH ORDER DATA)
PMC16	=	$		;***LOAD LOW ORDER DATA***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,BDL		;(LOW ORDER DATA)
	MV	WCR,CTR		;GET FLAG BITS (15-12)
PMCNEW	=	$		;***GET NEW FCNA CODE FROM PDP***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;ZERO TERMINATES FCNA LIST
PMCNXT	=	$		;***EXECUTE CAMAC WRITE***
	LCI	$+2		;RETURN POINT
	JP	CAMRW		;DO CAMAC OPERATION
	BCF	PMCNEW,C13	;IF C13 OFF (NOT Q-STOP MODE), NEXT FCNA
	BCT	PMCNXT,QF	;ELSE IF Q ON, REPEAT SAME FCNA
	JP	PMCNEW		;BUT IF Q OFF, DO NEXT FCNA

MP2CWT	=	$		;***FUNCTION: MBD WRITE, PDP TO CAMAC***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;ZERO MEANS NO MORE FCNA'S
	MV	WCR,CTR		;GET FLAG BITS (15-12)
MPCNXT	=	$		;***DO A CAMAC WRITE***
	BCF	MPC16,C15	;16 BIT WRITE IF C15 OFF, ELSE 24
	LCI	SETBHI		;RETURN POINT
READH	=	$		;***SUB TO READ PDP MEM & HOLD UNIBUS***
	INM	DAR,DAR		;GO TO NEXT WORD IN BUFFER
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BANK 1 WCR=LAST BUFFER LOC
	BCF	WCOF,CF		;IF LAST LOCATION LESS, REACHED BUF END
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	DAR,MAR,RDH	;READ A WORD & HOLD UNIBUS
	JP	WTDONE		;WAIT FOR IT TO ARRIVE
SETBHI	=	$		;***LOAD HIGH ORDER DATA***
	MV	MDR,BDH		;PUT DATA IN BDH (HIGH ORDER)
MPC16	=	$		;***GET LOW ORDER DATA***
	LCI	SETBLO		;RETURN POINT
READ	=	$		;***SUB TO READ PDP WORD FROM BUFFER***
	INM	DAR,DAR		;GO TO NEXT WORD IN BUFFER
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BANK 1 WCR=LAST BUFFER LOC
	BCF	WCOF,CF		;IF LAST LOCATION LESS, REACHED BUF END
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	DAR,MAR,RDR	;READ A WORD
WTDONE	=	$		;***WAIT FOR READ DONE***
	BCT	$,DCB		;WAIT FOR WORD TO ARRIVE
	JVC			;RETURN
SETBLO	=	$		;***LOAD LOW ORDER DATA***
	MV	MDR,BDL		;PUT DATA IN BDL (LOW ORDER)
DOCAM	=	$		;***DO CAMAC WRITE COMMAND***
	LCI	$+2		;RETURN POINT
	JP	CAMRW		;DO CAMAC WRITE
	BCF	MP2CWT,C13	;IF C13 OFF (NOT Q-STOP MODE), NEXT FCNA
	BCT	MPCNXT,QF	;ELSE IF Q ON, REPEAT SAME FCNA
	INM	ILR,CTR		;ELSE GET NEXT FCNA
	MV	MEM,CCR		;PUT IT IN CCR
	BCT	CONTN2,ZF	;ZERO MEANS NO MORE FCNA'S
	MV	WCR,CTR		;GET FLAG BITS (15-12)
	JP	DOCAM		;CO CAMAC WRITE WITH SAME DATA
WCOF	=	$		;***WORD CNT OVRFLD ON BUF READ/WRITE***
	BCT	$,DCB		;AWAIT UNIBUS READY
	CON	RDR		;RELEASE BUS IF HELD
	CON	BK0		;SELECT BANK 0
	LD	WCOFER		;END OF BUFFER ERROR CODE
	JP	ERRX		;DECLARE ERROR
PP2CWT	=	$		;***FUNCTION: PDP WRITE, PDP TO CAMAC***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD 
	MV	MDR,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;END OF FCNA LIST IF ZERO
	BCF	PPC16,C15	;16 BIT WRITE IF C15 OFF, ELSE 24
	LCI	$+2		;RETURN POINT
	JP	READH		;GET NEXT PDP WORD (& HOLD UNIBUS)
	MV	MDR,BDH		;(HIGH ORDER DATA)
PPC16	=	$		;***GET LOW ORDER DATA***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,BDL		;(LOW ORDER DATA)
	LCI	PP2CWT		;RETURN POINT (NEXT FCNA)
	JP	CAMRW		;DO CAMAC WRITE

MC2PRD	=	$		;***FUNCTION: MBD READ, CAMAC TO PDP***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;END OF FCNA LIST IF ZERO
	MV	WCR,CTR		;GET FLAG BITS (15-12)
MCPNXT	=	$		;***EXECUTE CAMAC READ***
	LCI	$+2		;RETURN POINT
	JP	CAMRW		;DO CAMAC READ
	BCF	MC2PRD,QF	;IF Q=0, GO TO NEXT FCNA (NO DATA READ)
	BCF	MCP16,C15	;16 BIT READ IF C15 OFF, ELSE 24
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	BDH,MDR		;SET HIGH ORDER DATA
	LCI	MCP16		;RETURN POINT
WRITEH	=	$		;***SUBR TO WRITE PDP WORD & HOLD BUS***
	INM	DAR,DAR		;NEXT BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BANK 1 WCR=LAST BUFFER LOC
	BCF	WCOF,CF		;IF LAST LOCATION IS LESS, AT END OF BUF
	CON	BK0		;SELECT BANK 0
	MV	DAR,MAR,WTH	;ELSE WRITE WORD & HOLD UNIBUS
	JVC			;RETURN
MCP16	=	$		;***WRITE LOW ORDER DATA***
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	BDL,MDR		;GET LOW ORDER DATA
	LCI	CHKMOR		;RETURN POINT
WRITE	=	$		;***SUB TO WRITE PDP WORD INTO BUFFER***
	INM	DAR,DAR		;NEXT BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BANK 1 WCR=LAST BUFFER LOC
	BCF	WCOF,CF		;IF LAST LOCATION IS LESS, AT END OF BUF
	CON	BK0		;SELECT BANK 0
	MV	DAR,MAR,WTR	;ELSE WRITE WORD
	JVC			;RETURN
CHKMOR	=	$		;***CHECK FOR MORE TO DO***
	BCT	MCPNXT,C13	;IF C13 ON (Q-STOP MODE), GET MORE WORDS
	JP	MC2PRD		;ELSE GET NEXT FCNA
PC2PRD	=	$		;***FUNCTION: PDP READ, CAMAC TO PDP***
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN2,ZF	;IF ZERO, REACHED END OF FCNA'S
	LCI	$+2		;RETURN POINT
	JP	CAMRW		;DO A CAMAC READ
	BCF	PCP16,C15	;16 BIT READ IF C15 OFF, ELSE 24
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	BDH,MDR		;GET HIGH ORDER DATA
	LCI	$+2		;RETURN POINT
	JP	WRITEH		;WRITE OUT DATA (& HOLD UNIBUS)
PCP16	=	$		;***WRITE LOW ORDER DATA***
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	BDL,MDR		;GET LOW ORDER DATA
	LCI	PC2PRD		;RETURN POINT (DO NEXT FCNA)
	JP	WRITE		;WRITE OUT DATA

MTSFUN	=	$		;***FUNCTION: MBD MANUAL TST FUNCTION***
	INM	ILR,CTR		;GET NEXT MBD WORD (READ SWITCHES FCNA)
	MV	MEM,BAR,BC0	;READ SWITCHES
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IN CCR (WRITE INTO LIGHTS FCNA)
	JP	TSFUNC		;GO EXECUTE
PTSFUN	=	$		;***FUNCTION: PDP MANUAL TST FUNCTION***
	LCI	$+2		;RETURN POINT
	JP	READH		;GET NEXT PDP WORD (READ SWITCHES FCNA)
	MV	MDR,BAR,BC0	;READ SWITCHES
	LCI	$+2		;RETURN POINT
	JP	READ		;GET NEXT PDP WORD
	MV	MDR,CCR		;PUT IN CCR (WRITE INTO LIGHTS FCNA)
TSFUNC	=	$		;***EXECUTE MANUAL TEST FUNCTION***
	LCI	7		;SET CTR = 7 (CHANNEL MASK)
	BCT	$,BRB		;WAIT FOR READ DONE
	BCF	CONTN2,QF	;IF NO Q RESPONSE, IGNORE REQUEST
	MV	BDH,ATR		;GET SWITCHES 17-24
	SRL	5		;GET SWITCHES 22-24 (CHANNEL NO.)
	AND	CTR,ATR		;MASK OUT REST OF JUNK
	SB	CCL,ATR		;COMPARE WITH ACTIVE CHANNEL NO.
	BCF	CONTN2,ZF	;NOT EQUAL: DON'T DO FUNCTION
	MV	BDH,ATR		;GET SWITCHES 17-24 AGAIN
	SLL	11.		;PUT 18-21 INTO BITS 12-15
	DEP	CTR		;AND SET CTR BITS 12-15
	LCI	TMADDR		;ADDRESS OF TEST MODULE ADDRESS WORD
	MV	BDH,ATR		;GET SWITCHES 17-24 AGAIN
	BCF	TMD,OF		;IF SWITCH 17 OFF, DON'T LOAD ADDRESS
	MV	BDL,MEM		;ELSE PUT SWITCHES 1-16 INTO ADDRESS
TMD	=	$		;***CHECK FOR DECREMENT***
	BCF	TMI,C12		;IF SWITCH 18 OFF, DON'T DECREMENT ADDR.
	DEM	MEM,MEM		;ELSE DO
TMI	=	$		;***CHECK FOR INCREMENT***
	BCF	TMF,C13		;IF SWITCH 19 OFF, DON'T INCREMENT ADDR.
	INM	MEM,MEM		;ELSE DO
TMF	=	$		;***DECODE TEST FUNCTION***
	BCT	TMRWD,C14	;IF SWITCH 20 ON, READ/WRITE OR DEPOSIT
	BCT	TMCTL,C15	;ELSE IF SWITCH 21 ON, CONTROL FCNA
	MV	MEM,CTR		;ELSE EXAMINE FUNCTION: GET ADDRESS
	MV	MEM,BDL		;PUT CONTENTS OF ADDR. INTO LIGHTS 1-16
	JP	TMDSPL		;GO DISPLAY IT
TMCTL	=	$		;***DO CAMAC CONTROL FUNCTION***
	MV	MEM,BAR,BC1	;DO CONTROL FCNA
	BCT	$,BRB		;WAIT FOR BRANCH READY
	DEP	BDL		;PUT FCNA INTO LIGHTS 1-16
	MV	0,BDH		;CLEAR LIGHTS 17-24
	BCF	$+2,XF		;SKIP IF NO X
	INM	BDH,BDH		;TURN ON LIGHT 17 IF X ON
	BCF	TMDSP2,QF	;GO DISPLAY IF NO Q
	INM	BDH,BDH		;TURN ON LIGHT 18...
	INM	BDH,BDH		;...IF Q ON
TMDSP2	=	$		;***DISPLAY RESULTS***
	JP	TMDSPL		;GO DISPLAY IT

TMRWD	=	$		;***DO READ/WRITE OR DEPOSIT FUNCTION***
	BCT	TMDEP,C15	;IF SWITCH 21 ON, DEPOSIT
	MV	0,BDH		;ELSE DO READ/WRITE: HIGH ORDER DATA 0
	MV	MEM,BAR,BC0	;LOW ORDER DATA FROM SWITCHES 1-16
	BCT	$,BRB		;WAIT FOR CAMAC DONE
	BCF	CONTN2,QF	;QUIT IF NO Q RESPONSE
	JP	TMDSPL		;DISPLAY RESULTS
TMERR2	=	$		;***TEST MODULE ERROR FUNCTION***
	JP	TMERR		;CHECK FOR MANUAL ERROR
TMDEP	=	$		;***DO DEPOSIT OR ERROR TERMINATION***
	MV	BDH,ATR		;GET SWITCHES 17-24
	BCT	TMERR2,OF	;IF SW 17 ON, DON'T DEPOSIT (PROTECTION)
	MV	MEM,GP1		;GET MBD ADDRESS INTO GP1
	LD	MBDSIZ		;GET MBD MEMORY SIZE (LAST WORD ADDR.+1)
	SB	GP1,ATR		;COMPARE WITH ADDRESS
	BCT	CONTN2,CF	;IF ADDR GREATER OR EQUAL, DON'T DEPOSIT
	LCI	MBDEND		;GET ADDR. OF FIRST WORD AFTER EXECUTIVE
	SB	GP1,ATR		;COMPARE WITH ADDRESS
	BCF	CONTN3,CF	;IF ADDRESS IS LESS, DON'T DEPOSIT
	MV	GP1,CTR		;PUT ADDRESS INTO CTR
	MV	BDL,MEM		;DEPOSIT COONTENTS OF SWITCHES 1-16
	MV	GP1,BDL		;SET LIGHTS 1-16 TO ADDRESS
TMDSPL	=	$		;***DISPLAY FUNCTION RESULT IN LIGHTS***
	MV	CCR,BAR,BC0	;WRITE DATA TO LIGHTS
	BCT	$,BRB		;WAIT FOR DONE
	JP	CONTIN		;DONE
TMERR	=	$		;***CHECK FOR MANUAL TERMINATION***
	LCI	340		;MASK FOR SWITCHES 22-24 (CHANNEL NO.)
	IOR	BDH,BDH		;IGNORE CHANNEL NUMBER
	INM	BDH,ATR		;ADD ONE
	BCF	CONTN3,ZLB	;IF NON-0 (NOT ALL SWS ON), SKIP REQUEST
	INM	BDL,ATR		;CHECK SWITCHES 1-16
	BCF	CONTN3,ZF	;IF NOT ALL ON, IGNORE REQUEST
	LD	MANER		;ELSE SET MANUAL TERMINATION CODE
	JP	ERRX		;DECLARE ERROR

HODORD	=	$		;***FUNCTION: READ HODOSCOPE TDC'S***
	INM	ILR,CTR		;GET NEXT MBD WORD
	DEM	MEM,GP1		;ONE LESS TO GP1 (STARTING TDC NUMBER-1)
HODNEW	=	$		;***GET NEW TDC READ FCNA***
	INM	GP1,GP1		;GO TO NEXT TDC NUMBER
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT INTO CCR (CAMAC FCNA)
	BCT	CONTN3,ZF	;IF ZERO, END OF FCNA LIST
	MV	CCR,BAR,BC0	;DO CAMAC READ FUNCTION
	BCT	$,BRB		;WAIT FOR READ DONE
	BCF	NOX2,XF		;IF X OFF, SIGNAL "NO X" ERROR
	BCF	NOQ2,QF		;IF Q OFF, "NO Q" ERROR
	MV	BDL,ATR		;GET TDC VALUE
	BCT	HODNEW,ZF	;IF ZERO, IGNORE IT
	LCI	7000		;MASK FOR OVERFLOW BIT
	AND	BDL,ATR		;MASK OUT OVERFLOW BIT ONLY
	BCF	HODNEW,ZF	;IF OVERFLOW (NO STOP PULSE), IGNORE IT
	INM	DAR,DAR		;GO TO NEXT BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BK1 WCR = LAST BUFFER ADDR.
	BCF	NOROOM,CF	;IF LAST ADDR. LESS, NO MORE ROOM IN BUF
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	DAR,MAR		;SET PDP BUFFER ADDRESS
	MV	GP1,MDR,WTH	;WRITE OUT TDC NUMBER & HOLD UNIBUS
	INM	DAR,DAR		;GO TO NEXT BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BK1 WCR = LAST BUFFER ADRR.
	BCF	NOROOM,CF	;IF LAST ADDR. LESS, NO MORE ROOM IN BUF
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	DAR,MAR		;SET PDP BUFFER ADRESS
	MV	BDL,MDR,WTR	;WRITE OUT TDC VALUE
	JP	HODNEW		;GO TO NEXT HODOSCOPE

DRCHRD	=	$		;***FUNCTION: READ DRIFT CHAMBERS***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,WCR		;PUT IT INTO WCR (STARTING WIRE NUMBER)
DRCNEW	=	$		;***GET NEW READ FCNA***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (CAMAC FCNA)
	BCT	CONTN3,ZF	;IF ZERO, END OF FCNA LIST
	BCF	RDCHBR,NF	;IF NON-NEGATIVE, IT'S CHAMBER READ
	MV	CCR,BAR,BC1	;ELSE EXECUTE AS A CONTROL FUNCTION
	BCT	$,BRB		;WAIT FOR COMPLETION
	JP	DRCNEW		;CONTINUE (NO ERROR CHECKS)
RDCHBR	=	$		;***SET UP TO READ A 2770***
	LCI	BUF1-1		;ADDRESS OF EVEN WIRE BUFFER
	DEP	GP1		;PUT IT INTO GP1 (POINTER)
	LCI	BUF2-1		;ADDRESS OF ODD WIRE BUFFER
	DEP	GP2		;PUT IT INTO GP2 (POINTER)
DRCNXT	=	$		;***READ NEXT WIRE & TOF***
	MV	CCR,BAR,BC0	;DO CAMAC READ
	BCT	$,BRB		;WAIT FOR READ DONE
	BCF	ENDBLK,XF	;IF X OFF, ASSUME MODULE MISSING & GO ON
	BCF	NOQ2,QF		;IF Q OFF, DECLARE "NO Q" ERROR
	MV	BDL,ATR		;GET WIRE DATA
	BCT	ENDBLK,NF	;IF BIT 15 ON, END OF DATA BLOCK
	SRL	8.		;GET WIRE NUMBER
	BCT	ODD,OF		;WIRE ADDRESS IS ODD (USE 2ND BUFFER)
	LCI	BUF1+NWIRS-1	;LAST WORD IN BUFFER 1
	SB	GP1,ATR		;ARE WE PAST IT YET?
	BCT	ENDBLK,CF	;YES, QUIT NOW (DON'T OVERFLOW BUFFER)
	INM	GP1,CTR		;NO, GO TO NEXT WORD
	MV	BDL,ATR		;GET WIRE DATA
	SRL	9.		;WIRE NUMBER DIVIDED BY 2
	AD	WCR,MEM		;ADD STARTING WIRE NO. & PUT IN BUFFER
	INM	GP1,CTR		;GO TO NEXT BUFFER LOCATION
	JP	STOTIM		;INSERT TOF NEXT
ODD	=	$		;***ODD WIRE ADDRESS (HIGH WIRES)***
	LCI	BUF2+NWIRS-1	;LAST WORD IN BUFFER 2
	SB	GP2,ATR		;ARE WE PAST IT YET?
	BCT	ENDBLK,CF	;YES, DON'T EXCEED BUFFER AREA
	INM	GP2,CTR		;NO, GO TO NEXT WORD
	MV	BDL,ATR		;GET WIRE DATA
	SRL	9.		;WIRE NUMBER DIVIDED BY 2
	AD	WCR,MEM		;ADD STARTING WIRE NO. & PUT IN BUFFER
	LD	HALFW		;GET ONE-HALF NO. OF WIRES
	AD	MEM,MEM		;ADD TO WIRE NUMBER
	INM	GP2,CTR		;GO TO NEXT BUFFER LOCATION
STOTIM	=	$		;***PUT TOF DATA INTO BUFFER***
	LD	MASK		;GET TOF MASK
	AND	BDL,MEM		;EXTRACT TOF AND SAVE IT IN BUFFER
	JP	DRCNXT		;DO NEXT WIRE NOW

ENDBLK	=	$		;***END OF 2770 DATA***
	LCI	BUF1-1		;START OF LOW WIRE BUFFER
TRANSF	=	$		;***TRANSFER WIRE DATA TO PDP***
	INM	CTR,CTR		;GO TO NEXT WORD IN BUFFER
	SB	GP1,ATR		;PAST END OF ACTUAL DATA?
	BCF	FINBUF,CF	;YES, THIS BUFFER IS FINISHED
	INM	DAR,DAR		;GO TO NEXT PDP BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BK1 WCR = LAST BUFFER ADDR.
	BCF	NOROOM,CF	;IF LAST ADDR. LESS, NO MORE ROOM IN BUF
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	MEM,MDR		;PUT WIRE NO. IN DATA REGISTER
	MV	DAR,MAR,WTH	;WRITE IT OUT & HOLD UNIBUS
	DEM	CTR,CTR		;GO BACKWARDS...
	DEM	CTR,CTR		;...TO PREVIOUS WIRE NUMBER
	MV	MDR,ATR		;GET THIS WIRE NO.
	SB	MEM,ATR		;COMPARE IT WITH LAST ONE READ
	BCT	WRGORD,CF	;IF LESS OR EQUAL, ERROR
	LD	THREE		;GO FORWARDS...
	AD	CTR,CTR		;...TO THIS WIRE'S TOF DATA
	INM	DAR,DAR		;GO TO NEXT PDP BUFFER ADDRESS
	CON	BK1		;SELECT BANK 1
	SB	WCR,ATR		;COMPARE WITH BK1 WCR = LAST BUFFER ADDR.
	BCF	NOROOM,CF	;IF LAST ADDR. LESS, NO MORE ROOM IN BUF
	CON	BK0		;SELECT BANK 0
	BCT	$,DCB		;WAIT FOR UNIBUS READY
	MV	MEM,MDR		;PUT TOF DATA IN DATA REGISTER
	MV	DAR,MAR,WTR	;WRITE OUT DRIFT TIME
	JP	TRANSF		;DO ALL DATA IN BUFFER
FINBUF	=	$		;***FINISHED ONE DATA BUFFER***
	MV	GP2,ATR		;DOES SECOND BUFFER EXIST?
	BCT	ALLFIN,ZF	;NO, ALL FINISHED
	MV	GP2,GP1		;YES, PUT LAST ADDRESS INTO GP1
	MV	0,GP2		;SET FLAG: NO MORE BUFFERS
	LCI	BUF2-1		;START OF HIGH WIRE BUFFER
	JP	TRANSF		;GO WRITE IT TO PDP
ALLFIN	=	$		;***END OF ONE 2770 REACHED***
	LCI	NWIRS		;NUMBER OF WIRES PER 2770
	AD	WCR,WCR		;UPDATE STARTING WIRE NUMBER
	JP	DRCNEW		;GO FETCH NEXT FCNA
WRGORD	=	$		;***WRONG ORDER FOR DRIFT WIRES READ***
	LCI	CE.ORD		;SET ORDERING FAILURE COMPLETION CODE
	JP	CLNUP		;CLEAN UP & TAKE ERROR EXIT
NOROOM	=	$		;***RAN OUT OF ROOM FOR DATA IN BUF***
	CON	BK0		;SELECT BANK 0
	DEM	DAR,DAR		;BACK UP BUFFER POINTER BY 1
	LCI	CE.NRM		;SET NON-FATAL COMPLETION CODE
CLNUP	=	$		;***CLEAN UP BUS I/O ON ERROR***
	BCT	$,DCB		;AWAIT UNIBUS READY
	CON	RDR		;RELEASE BUS IF HELD
	JP	ERRX		;TAKE ERROR EXIT
NOX2	=	$		;***NO X RESPONSE ERROR***
	JP	NOX		;SET ERROR CODE & TAKE ERROR EXIT

TOFCUT	=	$		;***FUNCTION: DO TOF CUTS ON TDC DATA***
	INM	ILR,CTR		;GET NEXT MBD WD (OFFSET TO REJECT BRCH)
	AD	MEM,WCR		;ADD CURRENT LOCATION & SAVE IN WCR
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,GP1		;SAVE IN GP1 (TIME DIFF FOR COSMICS * 3)
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,GP2		;SAVE IN GP2 (CUT POINT ON TOF DIST * 3)
	DEM	0,ATR		;LOAD -1 (FLAG)
	ST	TIMES		;FILL ARRAY OF TIMES WITH IT
	ST	TIMES+1
	ST	TIMES+2
	ST	TIMES+3
	ST	TIMES+4
	ST	TIMES+5		;(SIX LOCATIONS)
GETTDC	=	$		;***GET TDC VALUES & CHECK VALIDITY***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT IN CCR (TDC 1 READ FCNA)
	BCT	CONTN3,ZF	;IF ZERO, REACHED END OF TDC'S, EVENT OK
	MV	CCR,BAR,BC0	;READ TDC 1
	INM	ILR,CTR		;GET NEXT MBD WORD
	LD	MXDTDC		;GET MAXIMUM ALLOWED TDC VALUE
	BCT	$,BRB		;WAIT FOR READ TO FINISH
	BCF	NOQ2,QF		;IF NO Q, TAKE ERROR EXIT
	SB	BDL,ATR		;COMPARE TDC VALUE WITH MAXIMUM
	BCT	GETTDC,CF	;IF GREATER OR EQUAL, DO NEXT TWO TDC'S
	MV	MEM,CCR		;PUT TDC 2 READ FCNA IN CCR
	MV	BDL,CTR		;SAVE TDC 1 VALUE IN CTR
	MV	CCR,BAR,BC0	;READ TDC 2
	LD	MXDTDC		;GET MAXIMUM ALLOWED TDC VALUE
	BCT	$,BRB		;WAIT FOR READ TO FINISH
	BCF	NOQ2,QF		;IF NO Q, TAKE ERROR EXIT
	SB	BDL,ATR		;COMPARE TDC VALUE WITH MAXIMUM
	BCT	GETTDC,CF	;IF GREATER OR EQUAL, DO NEXT TWO TDC'S
	MV	BDL,ATR		;GET TDC 2 VALUE
	SLL	1		;SHIFT LEFT 1 BIT (MULTIPLY BY 2)
	AD	CTR,BDL		;ADD TDC 1 VALUE & SAVE IN BDL
	LCI	TIMES-1		;ADDR. OF TABLE OF TIMES - 1
TIMELP	=	$		;***COMPARE TIME WITH PREVIOUS TIMES***
	INM	CTR,CTR		;GO TO NEXT TIME IN TABLE
	MV	MEM,ATR		;GET PREVIOUS TIME VALUE FROM TABLE
	BCT	SAVEIT,NF	;IF NEGATIVE, NO MORE TIMES IN TABLE
	SB	BDL,ATR		;SUBTRACT FROM THIS ONE (EARLIEST FIRST)
	SB	GP1,ATR		;SUBTRACT FROM TIME DIFF FOR COSMICS * 3
	BCF	$+2,NF		;SKIP IF NOT NEGATIVE (ZERO OR POSITIVE)
	SB	0,ATR		;ELSE SUBTRACT FROM 0 (TAKE ABS VALUE)
	SB	GP2,ATR		;COMPARE IT WITH CUT POINT OF DIST * 3
	BCF	TIMELP,CF	;EVENT OK IF CUT POINT * 3 IS LESS
	JP	RJCT		;REJECT IF CUT * 3 IS GREATER OR EQUAL
SAVEIT	=	$		;***END OF TIME TABLE: SAVE TIME IF ROOM
	BCF	GETTDC,OF	;IF AT TABLE END (-2), DON'T SAVE TIME
	MV	BDL,MEM		;ELSE PUT IT INTO TABLE
	JP	GETTDC		;LOOP BACK
NOQ2	=	$		;***NO Q RESPONSE ON CAMAC READ***
	JP	NOQ		;TAKE "NO Q" ERROR EXIT

PHIMAT	=	$		;***FUNCTION: FIND PHI-MATCHED TRACKS***
	INM	ILR,CTR		;GET NEXT MBD WORD
	AD	MEM,WCR		;ADD CURRENT LOCATION & SAVE IT IN WCR
FNDMAT	=	$		;***FIND PHI-MATCHED TRACK***
	MV	0,GP1		;CLEAR GRP COUNTER (GP1)
NXTGRP	=	$		;***TEST COINCIDENCE GROUP FOR MATCH***
	INM	0,GP2		;SET SUBGRP COUNTER = 1
TESTA	=	$		;***TEST AND-GRP***
	INM	CTR,CTR		;GET NXT MBD WD
	MV	MEM,CCR		;PUT IT INTO CCR
	BCT	TESTA2,ZF	;IF 0, END OF AND PAIR
	BCT	MARKER,NF	;IF NEGATIVE, CHECK FOR END MARKER
	MV	CCR,BAR,BC0	;READ TDC
	LD	MAXTDC		;GET MAXIMUM ALLOWED TDC VALUE
	BCT	$,BRB		;WAIT FOR READ TO FINISH
	BCF	NOQ2,QF		;IF NO Q RESPONCE, ERROR
	SB	BDL,ATR		;COMPARE TDC VALUE WITH MAXIMUM
	BCT	TESTA3,CF	;IF GREATER OR EQUAL, NO HIT
	LD	MINTDC		;GET MINIMUM ALLOWED TDC VALUE
	SB      BDL,ATR		;COMPARE TDC VALUE TO MINIMUM
	BCT	TESTA1,CF	;IF GREATER OR EQUAL, HIT
TESTA3	=	$		;***AND-PAIR HAS NO HIT***
	DEM	GP2,GP2		;DECREMENT AND-PAIR COUNT
	BCT	NXTGRP,NF	;IF ZERO, TEST NEXT AND-PAIR
	INM	CTR,CTR		;IF GP2=1, SKIP ONE MBD WORD
	JP	NXTGRP		;TEST NEXT AND-PAIR
REVER1	=	$		;
	JP	REVERT		;
NOHIT1	=	$		;
	JP	NOHIT		;
TESTO4	=	$		;
	JP	TESTO1		;
MARKER	=	$		;***SEE IF ALL COUNTERS TRIED***
	BCT	REVER1,OF	;END OF ALL GROUPS REACHED
	MV	GP1,ATR		;AT MIDDLE; DOING MAIN TRACK SEARCH?
	BCF	TESTA,ZF	;NO; IGNORE MIDDLE MARK
RJCT	=	$		;***REJECT THE EVENT***
	MV	WCR,ILR		;SET MBD CHANE PRG ADDRESS TO REJECT ADDR
CONTN3	=	$		;***GO TO NEXT INSTRUCTION***
	JP	CONTIN		;DONE
TESTA1	=	$		;***ONE OF A PAIR HAS HIT***
	DEM 	GP2,GP2		;DECREMENT GP2
	BCT	TESTA,ZF	;IF GP2=1, TEST ANOTHER OF THE PAIR
	INM	0,GP2		;AND-PAIR HAS HIT; SET GP2=1
	INM	GP2,GP2		;NOW GP2=2
	JP	SKIP1		;TO SKIP AND- & FIRST OR-GRP
TESTA2	=	$		;***AND-PAIR HAS NO HIT; GO TO E'S***
	INM	0,GP2		;SET GP2=1
	INM	GP2,GP2		;NOW GP2=2
TESTO	=	$		;***CHECK:IF GP1=5 & GP2=0,SKIP 1ST WD***
	LD	NCHECK		;GET NCHECK IN ATR
	SB	GP1,ATR		;GP1=NCHECK?
	BCF	TESTO2,ZF	;NO, GO TO NORMAL ROUTINE
	MV	GP2,ATR		;GP2=0 (B OR C)?
	BCF	TESTO2,ZF	;NO
	INM	CTR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT INTO CCR
	BCT	NOHIT1,NF	;IF NEGATIVE, END OF GRP
	BCT	TESTO4,ZF	;IF ZERO, END OF SUB-GRP

TESTO2	=	$		;***IF GP1=1 & GP2=0, SKIP LAST MBD WD***
	INM	CTR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT INTO CCR
	BCT	NOHIT1,NF	;IF NEGATIVE, END OF GRP
	BCT	TESTO4,ZF	;IF ZERO, END OF SUB-GRP
	INM	0,ATR		;ATR=1
	SB	GP1,ATR		;GP1=1?
	BCF	TESTO3,ZF	;NO
	MV	GP2,ATR		;GP2=0 (B OR C)?
	BCF	TESTO3,ZF	;NO
	INM     CTR,CTR		;GET NEXT MBD WORD
	MV 	MEM,ATR		;PUT IT INTO ATR
	BCT	NOHIT1,NF	;IF NEGATIVE, END OF GRP (ONE WD SKIPPED)
	BCT	TESTO4,ZF	;IF ZERO, END OF SUB-GRP (ONE WD SKIPPED)
	DEM	CTR,CTR		;GO BACK BY ONE MBD WORD
TESTO3	=	$		;***TEST OR-GRP***
	MV	CCR,BAR,BC0	;READ TDC
	LD	MAXTDC		;GET MAXIMUM ALLOWED TDC VALUE
	BCT	$,BRB		;WAIT FOR READ TO FINISH
	BCF	NOQ2,QF		;IF NO Q RESPONCE, ERROR
	SB	BDL,ATR		;COMPARE TDC VALUE WITH MAXIMUM
	BCT	TESTO2,CF	;IF GREATER OR EQUAL, TRY NEXT TDC
	LD	MINTDC		;GET MINIMUM ALLOWED TDC VALUE
	SB	BDL,ATR		;COMPARE TDC VALUE WITH MINIMUM
	BCF	TESTO2,CF	;
SKIP1	=	$		;***SKIP SUB-GRP'S***
	INM	CTR,CTR		;GET NEXT MBD WORD
	MV	MEM,ATR		;TEST FOR ZERO AND NEGATIVE
	BCT	ONETRK,NF	;NEGATIVE; END OF GRP
	BCF	SKIP3,ZF	;NOT ZERO; KEEP SKIPPING
	DEM	GP2,GP2		;DECREMENT GP2 (GP2=2=>1=>0)
	BCT	SKIP3,NF	;GP2=0, KEEP SKIPPING
	BCT	TESTO5,ZF	;GP2=1, TRY NEXT OR-SUBGRP
SKIP3	=	$		;
	JP	SKIP1
TESTO1	=	$		;*** NO HIT IN OR-GRP***
	MV	GP2,ATR		;LOOKING AT B OR C (GP2=0)??
	BCT	TESTO5,ZF	;YES; KEEP LOOKING
	INM	0,GP2		;GP2=1
	JP	NOHIT		;NO; E'S HAVE NO HIT
ONETRK	=	$		;***FOUND ONE TRACK***
	MV	CTR,ILR		;SAVE CURRENT POSITION IN GRP
	MV	GP1,ATR		;DOING MAIN TRACK SEARCH?
	BCT	SKPFWD,ZF	;YES; SKIP FWD BY 180 DEGREES
FNDEND	=	$		;***FOUND TWO TRACKS; SKIP REST***
	INM	ILR,CTR		;GO TO NEXT MBD WORD
	MV	MEM,ATR		;CHECK FOR TERMINATOR
	BCF	FNDEND,NF	;NOT YET; SKIP WORD
	BCF	FNDEND,OF	;NOT FINAL TERMINATOR; KEEP SKIPPING
	SRL	1		;FINAL TERMINATOR ?
	BCF	FNDEND,OF	;NO (-3); CONTINUE 
	JP	CONTIN		;YES (-1); GO TO NEXT INSTRUCTION

NOHIT	=	$		;***NO HIT ANYWHERE IN OR-GRP***
	MV	GP1,ATR		;SEARCH FOR FIRST TRACK?
	BCT	CNTDWN,ZF	;YES; GO ON LOOKING
	DEM	GP1,GP1		;NO; TRIED ALL PLACES FOR SECOND TRACK?
	BCF	CNTDWN,ZF	;NO; KEEP LOOKING
REVERT	=	$		;***GO BACK TO MAIN TRACK SEARCH***
	MV	ILR,CTR		;GO BACK TO SAVED POSITION
	JP	FNDMAT		;FIND A PHI-MATCHED TRACK
SKPFWD	=	$		;***SKIP FORWARD 180 DEGREES***
	LD	NSKIP		;NO. OF GRP TO SKIP...
	DEP	GP2		;...IS NO. OF COUNTER GRPS
	LD	NCHECK		;NO. OF GRPS TO CHECK FOR TRACK
	DEP	GP1		;.....
CNTDWN	=	$		;***COUNT EACH GRP SKIPPED***
	DEM	GP2,GP2		;DECREMENT GRP COUNTER
	BCT	NXTGR1,NF	;IF 0, GO TO NEXT GRP
SKIP2	=	$		;***SKIP ENTIRE GRP***
	INM	CTR,CTR		;GET NEXT MBD WORD
	MV	MEM,ATR		;(READ TDC)
	BCF	SKIP2,NF	;NOT NEGATIVE;KEEP SKIPPING
	BCT	CNTDWN,OF	;ONE GRP SKIPPED
	JP	SKIP2		;KEEP SKIPPING
NXTGR1	=	$		;
	JP	NXTGRP		;
TESTO5	=	$		;
	JP	TESTO		;
;

WRTMEM	=	$		;***FUNCTION: WRITE LINK MEMORY***
	INM	ILR,CTR		;GET NEXT MBD WORD
	MV	MEM,CCR		;PUT IT INTO CCR (WRITE FCNA)
	CON	BK1		;SELECT BANK 1
	MV	DAR,ATR		;GET BANK 1 DAR=FIRST BUFFER ADDR-1
	CON	BK0		;SELECT BANK 0
	DEP	WCR		;SAVE BUFFER POINTER IN WCR
	SB	DAR,BDL		;SUBTRACT FROM LAST WORD USED=WORD COUNT
	LCI	3		;3=NUMBER OF "HEADER" WORDS
	AD	BDL,BDL		;ADD TO WORD COUNT
	MV	CCR,BAR,BC0	;WRITE TOTAL WORD COUNT INTO MEMORY
	CON	BK1		;SELECT BANK 1
	MV	GP1,ATR		;GET BANK 1 GP1=COMPLETION CODE
	CON	BK0		;SELECT BANK 0
	BCT	$,BRB		;WAIT FOR BRANCH READY
	BCF	NOQ3,QF		;IF NO Q, SIGNAL ERROR
	DEP	BDL		;SET BRANCH DATA=COMPLETION CODE
	MV	CCR,BAR,BC0	;WRITE COMPLETION CODE INTO MEMORY
	CON 	BK1		;SELECT BANK 1
	MV	CCR,ATR		;GET BANK 1 CCR=ERROR INFORMATION WORD
	CON	BK0		;SELECT BANK 0
	BCT	$,BRB		;AWAIT BRANCH READY
	BCF	NOQ3,QF		;QUIT IF NO Q RESPONSE
	DEP	BDL		;SET BRANCH DATA=ERROR INFORMATION
	BCT	$,DCB		;WAIT FOR UNIBUS READY
WMEMLP	=	$		;***LOOP TO WRITE INTO MEMORY***
	MV	CCR,BAR,BC0	;WRITE OUT WORD TO MEMORY
	INM	WCR,WCR		;GO TO NEXT PDP BUFFER ADDRESS
	SB	DAR,ATR		;COMPARE WITH LAST WORD IN BUFFER
	BCT	$,BRB		;WAIT FOR BRANCH READY
	BCF	NOQ3,QF		;IF NO Q, SIGNAL ERROR
	BCF	CONTN4,CF	;IF NEXT WORD PAST LAST, DONE
	MV	WCR,MAR,RDR	;ELSE READ ANOTHER WORD FROM PDP
	BCT	$,DCB		;WAIT FOR IT
	MV	MDR,BDL		;PUT INTO BRANCH DATA
	JP	WMEMLP		;LOOP
NOQ3	=	$		;
	JP	NOQ		;
;
NUMTST	=	$		;***FUNCTION: TEST NO. OF WORDS READ***
	INM	ILR,CTR		;GET NEXT MBD WD (OFFSET TO REJECT BRCH)
	AD	MEM,WCR		;ADD CURRENT LOCATION & SAVE IN WCR
	INM	ILR,CTR		;GET NEXT MBD WORD
	CON	BK1		;SELECT BANK 1
	MV	DAR,ATR		;GET BK 1 DAR=FIRST BUFFER ADDR - 1
	CON	BK0		;SELECT BANK 0
	DEP	GP2		;SAVE IT FOR LATER
	SB	DAR,GP1		;SUBTRACT FROM LAST USED ADDR GIVING
				;WORDS IN BUFFER
	MV	MEM,ATR		;GET MINIMUM NO. OF WORDS FOR GOOD EVENT
	SB	GP1,ATR		;COMPARE WITH ACTUAL NO. OF WORDS
	BCT	CONTN4,CF	;IF ACTUAL NO. GREATER OR EQUAL, EVENT OK
	MV	WCR,ILR		;ELSE SET CHAN PGM ADDR TO REJECT ADDR
	INM	GP2,DAR		;ALSO RESET BUFFER ADDR TO ORIGINAL + 1
CONTN4	=	$		;***CONTINUE WITH NEXT INSTRUCTION***
	JP	CONTIN		;NUMTST DONE
;

; DATA AREAS FOR MBD PROGRAM:
;
CHNADR	=	$		;NEXT AVAILABLE PLACE TO LOAD A CHAN PGM
	DATA	MBDEND		;START JUST PAST "EXECUTIVE"
TMADDR	=	$		;TEST MODULE MBD ADDRESS OR CAMAC FCNA
	DATA	177777		;(BIG NUMBER)
INVER	=	$		;ERROR CODE FOR INVALID CHAN INSTRUCTION
				;OR NO CHANNEL PROGRAM LOADED
	DATA	CE.INV
OUTER	=	$		;ERROR CODE FOR BUFFER PTR OUT OF RANGE
	DATA	CE.OUT
BADER	=	$		;ERROR CODE FOR BAD MBD ADDRESS
	DATA	CE.ADR
NOQER	=	$		;ERROR CODE FOR "NO Q" AFTER CAMAC FUNCT
	DATA	CE.NOQ
NOXER	=	$		;ERROR CODE FOR "NO X" AFTER CAMAC FUNCT
	DATA	CE.NOX
WCOFER	=	$		;ERROR CODE FOR END OF BUFFER REACHED
	DATA	CE.EOB
MANER	=	$		;ERROR CODE FOR MANUAL CHAN TERMINATION
	DATA	CE.MAN
DFCHAD	=	$		;DEFAULT CHANNEL ENTRY ADDRESS
	DATA	INVCHN		;POINTS TO INVALID CHANEL INSTRUCTION 
MBDSIZ	=	$		;SIZE OF MBD MEMORY (LAST ADDRESS + 1)
MEMSIZ::DATA	MBDMEM		;ASSEMBLE DEFAULT, CHANGE BEFORE LOADING
HALFW	=	$		;ONE-HALF NO. OF WIRES IN ONE 2770
	DATA	NWIRS/2
MASK	=	$		;MASK FOR TOF DATA IN 2770 WORD
	DATA	377		;TOF DATA IS IN BITS 0-7
THREE	=	$		;CONSTANT (3)
	DATA	3
MAXTDC	=	$		;MAXIMUM ALLOWABLE TDC VALUE
	DATA	TDCMAX		; .GE. THIS VALUE -> OVERFLOW (NO STOP)
MINTDC	=	$		;MINIMUM ALLOWED TDC VALUE
	DATA	TDCMIN		;.LT. THIS VALUE ->NOT GOOD DATA
NSKIP	=	$		;NO. OF GRP TO SKIP FOR 2ND TRACK
	DATA	<NHALF-<NRANG/2>-1>
NCHECK	=	$		;NO. OF COUNTER GRPS TO CHK FOR 2ND TRACK
	DATA	NRANG
MXDTDC	=	$		;MAXIMUM ALLOWED TDC VALUE (FOR TOF CUT)
	DATA	TDCDMX		;.GE. THIS VALUE -> OVERFLOW <NO STOP>
	DATA	0,0		;DUMMY WIRE FOR LAST WIRE NO. TEST
BUF1	=	$		;FIRST 2770 WIRE DATA BUFFER
	RSWD	NWIRS		;TWO WORDS FOR EACH EVEN WIRE
	DATA	0,0		;DUMMY WIRE FOR LAST WIRE NO. TEST
BUF2	=	$		;SECOND 2770 WIRE DATA BUFFER
	RSWD	NWIRS		;TWO WORDS FOR EACH ODD WIRE
TIMES	=	$		;ARRAY OF TIME VALUES FOR TOF CUT FUNCT
	DATA	-1,-1,-1,-1,-1,-1;SAVE UP TO 6 TIMES IN TABLE
	DATA	-2		;END OF TABLE MARKER
DSPTCH	==	$		;DISPATCH TABLE FOR CHANNEL ENTRY
	DATA	INVCHN		;CHAN 0 ABORT ENTRY
	DATA	INVCHN		;CHAN 0 NORMAL ENTRY
	DATA	INVCHN		;CHAN 1 ABORT ENTRY
	DATA	INVCHN		;CHAN 1 NORMAL ENTRY
	DATA	INVCHN		;CHAN 2 ABORT ENTRY
	DATA	INVCHN		;CHAN 2 NORMAL ENTRY
	DATA	INVCHN		;CHAN 3 ABORT ENTRY
	DATA	INVCHN		;CHAN 3 NORMAL ENTRY
	DATA	INVCHN		;CHAN 4 ABORT ENTRY
	DATA	INVCHN		;CHAN 4 NORMAL ENTRY
	DATA	INVCHN		;CHAN 5 ABORT ENTRY
	DATA	INVCHN		;CHAN 5 NORMAL ENTRY
	DATA	INVCHN		;CHAN 6 ABORT ENTRY
	DATA	INVCHN		;CHAN 6 NORMAL ENTRY
	DATA	STPCHN		;CHAN 7 ABORT ENTRY
	DATA	PDPCHN		;CHAN 7 NORMAL ENTRY (CONTROL CHANNEL)
PDPCHN	=	$		;***CONTROL CHANEL (7)***
	DATA	CM.EXP		;EXECUTE PDP CHANNEL PROGRAM
STPCHN	=	$		;***END OF CHANNEL OPERATIONS***
	DATA	CM.STP		;STOP CHANNEL
INVCHN	=	$		
	DATA	-1		;INVALID INSTRUCTION
;

;
; MBD CHANNEL INSTRUCTION DISPATCH TABLE:
;
MBDFUN	=	$		
	DATA	STOP		;STOP CHANNEL
	DATA	CONTIN		;CONTINUE (NO-OP)
	DATA	EXECP		;EXECUTE PDP CHANNEL PROGRAM
	DATA	CONTIN		;EXECUTE MBD CHANNEL PROGRAM (NO-OP)
	DATA	RESTRT		;SET RE-ENTRY ADDRESS (MARK)
	DATA	EXIT		;CHANNEL EXIT
	DATA	INTR		;INTERRUPT PDP-11
	DATA	WCSEND		;SEND WORD COUNT TO PDP BUFFER
	DATA	MERROR		;SIGNAL ERROR
	DATA	PERROR		;SIGNAL ERROR FROM PDP BUFFER
	DATA	PAUSE		;PAUSE (WAIT FOR LAM)
	DATA	MNEXT		;DECREMENT COUNT AND BRANCH IF NON-ZERO
	DATA	MGOTO		;JUMP TO ANOTHER LOCATION
	DATA	SKIP		;SKIP NEXT LOCATION
	DATA	MMOVE		;MOVE PDP BUFFER POINTER FWD OR BKWD
	DATA	ADVNCE		;MOVE PDP BUFFER POINTER 1 WORD AHEAD
	DATA	MBRNCH		;BRANCH ON CONDITION (Q OR X)
	DATA	MBITST		;CONDITIONAL JUMP ON MASKED VALUE
	DATA	MLOOP		;LOAD LOOP COUNT
	DATA	PLOOP		;LOAD LOOP COUNT FROM PDP BUFFER
	DATA	MJMPER		;SET ERROR EXIT ADDRESS
	DATA	FLUSH		;CLEAR ALL MBD CHAN PGMS (EXCEPT 7)
	DATA	PLOAD		;LOAD MBD CHANNEL PGM FROM PDP BUFFER
	DATA	PDEPOS		;DEPOSIT NO. FROM PDP BUFFER INTO MBD
	DATA	PEXAM		;EXAMINE MBD MEMORY (SEND TO PDP BUFFER)
	DATA	MSEND		;SEND A WORD TO PDP BUFFER
	DATA	INIT		;CAMAC BZ (BRANCH INITIALIZE)
	DATA	MCNTRL		;EXECUTE CAMAC CONTROL FCNA'S
	DATA	PCNTRL		;EXECUTE CAMAC CONTROL FCNA'S IN PDP BUF
	DATA	MM2CWT		;DO MBD TO CAMAC WRITE
	DATA	PM2CWT		;DO MBD TO CAMAC WRITE, FCNAS IN PDP BUF
	DATA	MP2CWT		;DO PDP TO CAMAC WRITE
	DATA	PP2CWT		;DO PDP TO CAMAC WRITE, FCNAS IN PDP BUF
	DATA	MM2CWT		;DO IMMEDIATE (MBD) TO CAMAC WRITE
	DATA	MC2PRD		;DO CAMAC TO PDP READ
	DATA	PC2PRD		;DO CAMAC TO PDP READ, FCNA'S IN PDP BUF
	DATA	MTSFUN		;DO TEST MODULE FUNCTION
	DATA	PTSFUN		;DO TEST MODULE FUNCT, FCNA'S IN PDP BUF
	DATA	HODORD		;READ OUT HODOSCOPE TDC DATA
	DATA	DRCHRD		;READ OUT LECROY 2770 DRIFT CHANBER DATA
	DATA	TOFCUT		;DO TOF CUT ON HODOSCOPE TDC DATA
	DATA	PHIMAT		;DO PHI-MATCHING AND FIND NO. OF TRACKS
	DATA	WRTMEM		;WRITE EVENT INTO FIFO LINK MEMORY
	DATA	NUMTST		;TEST NO. OF WORDS IN BUFFER
NFCMBD	=	$-MBDFUN	;NO. OF MBD FUNCTIONS
;

; PDP CHANNEL INSTRUCTION DISPATCH TABLE:
;
PDPFUN	=	$
	DATA	STOP		;STOP CHANNEL
	DATA	CONTIN		;CONTINUE (NO-OP)
	DATA	CONTIN		;EXECUTE PDP CHANNEL PROGRAM (NO-OP)
	DATA	EXECM		;EXECUTE MBD CHANNEL PROGRAM
	DATA	RESTRT		;SET RE-ENTRY ADDRESS (MARK)
	DATA	EXIT		;CHANNEL EXIT
	DATA	INVLID		;***INVALID PDP INSTRUCTION***
	DATA	WCSEND		;SEND WORD COUNT TO PDP BUFFER
	DATA	PERROR		;SIGNAL ERROR
	DATA	PERROR		;SIGNAL ERROR (SAME AS CM.ERR)
	DATA	PAUSE		;PAUSE (WAIT FOR LAM)
	DATA	PNEXT		;DECREMENT COUNT AND BRANCH IF NON-ZERO
	DATA	PGOTO		;JUMP TO ANOTHER LOCATION
	DATA	ADVNCE		;SKIP NEXT LOCATION
	DATA	PGOTO		;MOVE POINTER (SAME AS CM.JMP)
	DATA	ADVNCE		;FORWARD 1 WORD (SAME AS CM.SKP)
	DATA	PBRNCH		;BRANCH ON CONDITION (Q OR X)
	DATA	PBITST		;CONDITIONAL JUMP ON MASKED VALUE TEST
	DATA	PLOOP		;LOAD LOOP COUNT
	DATA	PLOOP		;LOAD LOOP COUNT (SAME AS CM.LCO)
	DATA	PJMPER		;SET ERROR EXIT ADDRESS
	DATA	FLUSH		;CLEAR ALL MBD CHANNEL PGMS (EXCEPT 7)
	DATA	PLOAD		;LOAD MBD CHANNEL PGM FROM PDP BUFFER
	DATA	PDEPOS		;DEPOSIT NO. FROM PDP BUFFER INTO MBD
	DATA	PEXAM		;EXAMINE MBD MEMORY (SEND TO PDP BUFFER)
	DATA	INVLID		;***INVALID PDP INSTRUCTION***
	DATA	INIT		;CAMAC BZ (BRANCH INITIALIZE)
	DATA	PCNTRL		;EXECUTE CAMAC CONTROL FCNA'S
	DATA	PCNTRL		;EXEC CAMAC CONTROL FCNA'S (AS CM.CTL)
	DATA	INVLID		;***INVALID PDP INSTRUCTION***
	DATA	INVLID		;***INVALID PDP INSTRUCTION***
	DATA	PP2CWT		;DO PDP TO CAMAC WRITE
	DATA	PP2CWT		;DO PDP TO CAMAC WRITE (SAME AS CM.P2C)
	DATA	PP2CWT		;DO IMMEDIATE (PDP) TO CAMAC WRITE
	DATA	PC2PRD		;DO CAMAC TO PDP READ
	DATA	PC2PRD		;DO CAMAC TO PDP READ (SAME AS CM.PCP)
	DATA	PTSFUN		;DO TEST MODULE FUNCTION
	DATA	PTSFUN		;DO TEST MODULE FUNCT (SAME AS CM.TST)
NFCPDP	=	$-PDPFUN	;NO. OF PDP FUNCTIONS
;
; END OF MBD "EXECUTIVE"
;
MBDEND	==	$
MBDLEN	==	.-MBDPGM
;
	.END