01 0001  	
01 0002  	
01 0003  	;MEMTST  Memory diagnostic
01 0004  	;128k, new tape ctrl version
01 0005  	
01 0006  1 	NMEMS = 1       ;Test only 128k words.
01 0007  	
01 0008  	XLIST
01m0009                               	LIST
01m0009                               	
01m0009       1	NTP = 1  ;NEW TAPE CONTROLLER
01m0009                               	
01m0009                               	.INSERT MEMTST

SLOE   Jan ***, 1859 00:00:03  file DSK:MEMTST.SLO  --  of -- MEMT1

01m0001                               	;;; MEMTST - F2/F3 memory tester. 
01m0001                               	;Version of 1/19/81  DWP
01m0001                               	
01m0001                               	;Header file defines NMEMS, which controls the amount of
01m0001                               	; memory to be tested.  NMEMS = the number of card-pairs to
01m0001                               	; be tested.
01m0001                               	
01m0001       0	OTP = 1 - NTP
01m0001                               	
01m0001                               	.REPEAT NTP [
01m0001       0	TTY.DI = 0      ;read data
01m0001       12	TTY.WD = 12     ;write data
01m0001       14	TTY.WC = 14     ;write control
01m0001                               	  ];NTP
01m0001                               	
01m0001                               	.REPEAT OTP [
01m0001                               	;OTP
01m0001                               	
01m0001                               	: 2000
01m0001                               	
01m0001 02000 640341614571000040002001	INIT:   D[CONST 4] DEST[DEV-ADR] JPOP[. + 1] NORM $
01m0001 02001 640340014171014040002002	        D[CONST 4] ROT[6] DEST[Q] NORM JPOP[. + 1] $
01m0001 02002 640702400571000440000000	        DEST[CLR-DEV-FROM-INTR] NORM $
01m0001 02003 640700014175000740000000	        D[CONST 74] ALU[DORQ] DEST[Q] NORM $
01m0001 02004 640702214575014033600000	        D[CONST 3] ROT[6] ALU[DORQ] DEST[IOD] SPEC[IOB-OUT] NORM $
01m0001 02005 440340000571000440142006	        MAPF[TTY.WC] CYLEN[IOB-OUT] JPOP[. + 1] $
01m0001 02006 640342200555000443602007	        ALU[Q] DEST[IOD] SPEC[IOB-OUT] JPOP[. + 1] NORM $
01m0001 02007 440340000571000440142010	        MAPF[TTY.WC] CYLEN[IOB-OUT] JPOP[. + 1] $
01m0001                               	
01m0001                               	 .IF NMEMS > 2
01m0001                               	   [    01m0001                               	;IF NMEMS > 2
01m0001                               	
01m0001                               	 ;; Now we clear memory.
01m0001 02010 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0001 02011 640704200615000440000000	ZLOOP:  ALU[0] DEST[MEMSTO] NORM $
01m0001 02012 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0001                               	                ;Advance to next location.
01m0001 02013 030140014537042010002011	        D[CONST NMEMS] ROT[17.] ALU[D-Q] -OBUS=0 JUMP[ZLOOP] $
01m0001                               	                ;Check for the XEND-of memory.  Loop if not.
01m0001 02014 000343600571000440002015	        DEST[CLR-MI-ERR] JPOP[. + 1] $
01m0001                               	
01m0001                               	.DEFINE TYPLET 01m0001                               	
01m0001                               	.DEFINE TYPSPC 01m0001                               	         ; prnt <SPACE> 
01m0001                               	
01m0001                               	        TYPLET[01m0001 02015 640040014171000150000000	D[CONST 15] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"M"
01m0001                               	        TYPLET[01m0001 02016 640040014171000050000000	D[CONST 05] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"E"
01m0001                               	        TYPLET[01m0001 02017 640040014171000150000000	D[CONST 15] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"M"
01m0001                               	        TYPLET[01m0001 02020 640040014171000240000000	D[CONST 24] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"T"
01m0001                               	        TYPLET[01m0001 02021 640040014171000230000000	D[CONST 23] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"S"
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0001                               	        TYPLET[01m0001 02022 640040014171000240000000	D[CONST 24] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"T"
01m0001 02023 000040000571000440000000	        PUSHJ[TCR] $    ;<return><linefeed>
01m0001 02024 640341614571000010000000	STRTLP: D[CONST 1] DEST[DEV-ADR] NORM JPOP[TESTS] $
01m0001                               	
01m0001                               	 .DEFINE TEST 01m0001                               	 .DEFINE TESTA 01m0001                               	 .DEFINE TESTC 01m0001                               	
01m0001       0	TNUM = 0 ;Sequence no. of test currently running (typed on errors)
01m0001                               	
01m0001                               	TESTS:  TEST[01m0001 02025 640050010571000000002027	D[MASK 0] DEST[AR] PUSHJ[. + 2] NORM $
01m0001                               	                ;Setup thing to test with
01m0001 02026 000140000571000440000000	        JUMP[ZTSTX] $   ;Go to next test.
01m0001       1	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0001 02027 000041014571000013000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0001                               	          ;Put it where error typeouts can find it.
01m0001 02030 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0001                               	                ;Start at memory address 0
01m0001 02031 640714200571002440000000	ZTST:   D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0001                               	                ;Rotate test value and store new value in memory
01m0001                               	
01m0001 02032 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0001 02033 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0001 02034 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0001                               	                ;Check the result of the examine against what was expected
01m0001                               	                ;and if no error, prepare to check ECC
01m0001 02035 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0001                               	         ;JMP if ECC err
01m0001 02036 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0001                               	                ;Advance to next location
01m0001 02037 470140014537042010002031	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[ZTST] C600 $
01m0001                               	                ;Check for XEND-of memory to be tested
01m0001 02040 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0001                               	                ;Set repeat count for this test and clear error we may
01m0001                               	                ;have gotten from running off the XEND-of memory
01m0001 02041 640710010571000000000000	T12:    D[MASK 0] DEST[AR] NORM $
01m0001                               	                ;Setup same thing to test against
01m0001 02042 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0001                               	                ;Start again from the beginning of memory
01m0001                               	                ;Also, fetch first word from memory
01m0001 02043 640710000171002440000000	T11:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0001                               	                ;Rotate test value by one and put it where we can
01m0001                               	                ;test with it easier
01m0001 02044 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0001                               	                ;Check the result of the examine against what was expected
01m0001                               	                ;and if no error, prepare to check ECC
01m0001 02045 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0001                               	         ;JMP if ECC err
01m0001 02046 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0001                               	                ;Advance to next location and start the examine
01m0001 02047 470140014537042010002043	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T11] C600 $
01m0001                               	                ;Check for the XEND-of memory.  Loop if not.
01m0001 02050 640243600571000440002041	        LOOP[T12] DEST[CLR-MI-ERR] NORM $
01m0001                               	                ;Repeat the examine phase N times.
01m0001                               	                ;(No more MA 18 jumper!!!)
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0001 02051 000300000571000440000000	        POPJ $
01m0001                               	ZTSTX:
01m0002                               	]       TEST[01m0002 02052 640050010571000440002054	D[MASK 44] DEST[AR] PUSHJ[. + 2] NORM $
01m0002                               	                ;Setup thing to test with
01m0002 02053 000140000571000440000000	        JUMP[OTSTX] $   ;Go to next test.
01m0002       2	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0002 02054 000041014571000023000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0002                               	          ;Put it where error typeouts can find it.
01m0002 02055 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0002                               	                ;Start at memory address 0
01m0002 02056 640714200571002440000000	OTST:   D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0002                               	                ;Rotate test value and store new value in memory
01m0002                               	
01m0002 02057 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0002 02060 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0002 02061 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0002                               	                ;Check the result of the examine against what was expected
01m0002                               	                ;and if no error, prepare to check ECC
01m0002 02062 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0002                               	         ;JMP if ECC err
01m0002 02063 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0002                               	                ;Advance to next location
01m0002 02064 470140014537042010002056	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[OTST] C600 $
01m0002                               	                ;Check for XEND-of memory to be tested
01m0002 02065 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0002                               	                ;Set repeat count for this test and clear error we may
01m0002                               	                ;have gotten from running off the XEND-of memory
01m0002 02066 640710010571000440000000	T22:    D[MASK 44] DEST[AR] NORM $
01m0002                               	                ;Setup same thing to test against
01m0002 02067 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0002                               	                ;Start again from the beginning of memory
01m0002                               	                ;Also, fetch first word from memory
01m0002 02070 640710000171002440000000	T21:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0002                               	                ;Rotate test value by one and put it where we can
01m0002                               	                ;test with it easier
01m0002 02071 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0002                               	                ;Check the result of the examine against what was expected
01m0002                               	                ;and if no error, prepare to check ECC
01m0002 02072 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0002                               	         ;JMP if ECC err
01m0002 02073 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0002                               	                ;Advance to next location and start the examine
01m0002 02074 470140014537042010002070	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T21] C600 $
01m0002                               	                ;Check for the XEND-of memory.  Loop if not.
01m0002 02075 640243600571000440002066	        LOOP[T22] DEST[CLR-MI-ERR] NORM $
01m0002                               	                ;Repeat the examine phase N times.
01m0002                               	                ;(No more MA 18 jumper!!!)
01m0002 02076 000300000571000440000000	        POPJ $
01m0002                               	OTSTX:
01m0003                               	]       TESTA[01m0003 02077 640062600615000440002101	ALU[0] DEST[MA HI-ABS-MA] PUSHJ[. + 2] NORM $
01m0003                               	                ;Start at memory address 0
01m0003 02100 000140000571000440000000	        JUMP[ADRRX] $   ;Go to next test.
01m0003       3	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0003 02101 000041014571000033000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0003                               	          ;Put it where error typeouts can find it.
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0003 02102 640714224571000440000000	ADRR:   D[MA] ROT[0] ALU[D] DEST[AR MEMSTO] NORM $
01m0003                               	                ;Perform function D on MA and store it
01m0003                               	
01m0003 02103 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0003 02104 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0003 02105 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0003                               	                ;Check the result of the examine against what was expected
01m0003                               	                ;and if no error, prepare to check ECC
01m0003 02106 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0003                               	         ;JMP if ECC err
01m0003 02107 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0003                               	                ;Advance to next location
01m0003 02110 470140014537042010002102	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[ADRR] C600 $
01m0003                               	                ;Check for XEND-of memory to be tested
01m0003 02111 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0003                               	                ;Set repeat count for this test and clear error we may
01m0003                               	                ;have gotten from running off the XEND-of memory
01m0003 02112 640722600615000440000000	A12:    ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0003                               	                ;Start again from the beginning of memory
01m0003                               	                ;Also, fetch first word from memory
01m0003 02113 640710024171000440000000	A11:    D[MA] ROT[0] ALU[D] DEST[AR Q] NORM $
01m0003                               	                ;Apply function D to MA and put it where we can
01m0003                               	                ;test with it easier
01m0003 02114 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0003                               	                ;Check the result of the examine against what was expected
01m0003                               	                ;and if no error, prepare to check ECC
01m0003 02115 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0003                               	         ;JMP if ECC err
01m0003 02116 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0003                               	                ;Advance to next location and start the examine
01m0003 02117 470140014477042010002113	        D[CONST NMEMS] ROT[17.] ALU[Q-D] COND[-OBUS=0] JUMP[A11] C600 $
01m0003                               	                ;Check for the XEND-of memory.  Loop if not.
01m0003 02120 640243600571000440002112	        LOOP[A12] DEST[CLR-MI-ERR] NORM $
01m0003                               	                ;Repeat the examine phase N times.
01m0003                               	                ;(No more MA 18 jumper!!!)
01m0003 02121 000300000571000440000000	        POPJ $
01m0003                               	ADRRX:
01m0004                               	]       TESTA[01m0004 02122 640062600615000440002124	ALU[0] DEST[MA HI-ABS-MA] PUSHJ[. + 2] NORM $
01m0004                               	                ;Start at memory address 0
01m0004 02123 000140000571000440000000	        JUMP[ADRRNX] $  ;Go to next test.
01m0004       4	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0004 02124 000041014571000043000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0004                               	          ;Put it where error typeouts can find it.
01m0004 02125 640714224771000440000000	ADRRN:  D[MA] ROT[0] ALU[NOTD] DEST[AR MEMSTO] NORM $
01m0004                               	                ;Perform function NOTD on MA and store it
01m0004                               	
01m0004 02126 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0004 02127 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0004 02130 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0004                               	                ;Check the result of the examine against what was expected
01m0004                               	                ;and if no error, prepare to check ECC
01m0004 02131 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0004                               	         ;JMP if ECC err
01m0004 02132 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0004                               	                ;Advance to next location
01m0004 02133 470140014537042010002125	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[ADRRN] C600 $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0004                               	                ;Check for XEND-of memory to be tested
01m0004 02134 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0004                               	                ;Set repeat count for this test and clear error we may
01m0004                               	                ;have gotten from running off the XEND-of memory
01m0004 02135 640722600615000440000000	A22:    ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0004                               	                ;Start again from the beginning of memory
01m0004                               	                ;Also, fetch first word from memory
01m0004 02136 640710024371000440000000	A21:    D[MA] ROT[0] ALU[NOTD] DEST[AR Q] NORM $
01m0004                               	                ;Apply function NOTD to MA and put it where we can
01m0004                               	                ;test with it easier
01m0004 02137 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0004                               	                ;Check the result of the examine against what was expected
01m0004                               	                ;and if no error, prepare to check ECC
01m0004 02140 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0004                               	         ;JMP if ECC err
01m0004 02141 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0004                               	                ;Advance to next location and start the examine
01m0004 02142 470140014477042010002136	        D[CONST NMEMS] ROT[17.] ALU[Q-D] COND[-OBUS=0] JUMP[A21] C600 $
01m0004                               	                ;Check for the XEND-of memory.  Loop if not.
01m0004 02143 640243600571000440002135	        LOOP[A22] DEST[CLR-MI-ERR] NORM $
01m0004                               	                ;Repeat the examine phase N times.
01m0004                               	                ;(No more MA 18 jumper!!!)
01m0004 02144 000300000571000440000000	        POPJ $
01m0004                               	ADRRNX:
01m0005                               	]       TESTA[01m0005 02145 640062600615000440002147	ALU[0] DEST[MA HI-ABS-MA] PUSHJ[. + 2] NORM $
01m0005                               	                ;Start at memory address 0
01m0005 02146 000140000571000440000000	        JUMP[ADRLX] $   ;Go to next test.
01m0005       5	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0005 02147 000041014571000053000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0005                               	          ;Put it where error typeouts can find it.
01m0005 02150 640714224571034440000000	ADRL:   D[MA] ROT[14.] ALU[D] DEST[AR MEMSTO] NORM $
01m0005                               	                ;Perform function D on MA and store it
01m0005                               	
01m0005 02151 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0005 02152 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0005 02153 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0005                               	                ;Check the result of the examine against what was expected
01m0005                               	                ;and if no error, prepare to check ECC
01m0005 02154 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0005                               	         ;JMP if ECC err
01m0005 02155 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0005                               	                ;Advance to next location
01m0005 02156 470140014537042010002150	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[ADRL] C600 $
01m0005                               	                ;Check for XEND-of memory to be tested
01m0005 02157 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0005                               	                ;Set repeat count for this test and clear error we may
01m0005                               	                ;have gotten from running off the XEND-of memory
01m0005 02160 640722600615000440000000	A32:    ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0005                               	                ;Start again from the beginning of memory
01m0005                               	                ;Also, fetch first word from memory
01m0005 02161 640710024171034440000000	A31:    D[MA] ROT[14.] ALU[D] DEST[AR Q] NORM $
01m0005                               	                ;Apply function D to MA and put it where we can
01m0005                               	                ;test with it easier
01m0005 02162 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0005                               	                ;Check the result of the examine against what was expected
01m0005                               	                ;and if no error, prepare to check ECC
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0005 02163 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0005                               	         ;JMP if ECC err
01m0005 02164 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0005                               	                ;Advance to next location and start the examine
01m0005 02165 470140014477042010002161	        D[CONST NMEMS] ROT[17.] ALU[Q-D] COND[-OBUS=0] JUMP[A31] C600 $
01m0005                               	                ;Check for the XEND-of memory.  Loop if not.
01m0005 02166 640243600571000440002160	        LOOP[A32] DEST[CLR-MI-ERR] NORM $
01m0005                               	                ;Repeat the examine phase N times.
01m0005                               	                ;(No more MA 18 jumper!!!)
01m0005 02167 000300000571000440000000	        POPJ $
01m0005                               	ADRLX:
01m0006                               	]       TEST[01m0006 02170 640050010571000430002172	D[MASK 43] DEST[AR] PUSHJ[. + 2] NORM $
01m0006                               	                ;Setup thing to test with
01m0006 02171 000140000571000440000000	        JUMP[LHOLX] $   ;Go to next test.
01m0006       6	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0006 02172 000041014571000063000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0006                               	          ;Put it where error typeouts can find it.
01m0006 02173 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0006                               	                ;Start at memory address 0
01m0006 02174 640714200571002440000000	LHOL:   D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0006                               	                ;Rotate test value and store new value in memory
01m0006                               	
01m0006 02175 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0006 02176 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0006 02177 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0006                               	                ;Check the result of the examine against what was expected
01m0006                               	                ;and if no error, prepare to check ECC
01m0006 02200 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0006                               	         ;JMP if ECC err
01m0006 02201 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0006                               	                ;Advance to next location
01m0006 02202 470140014537042010002174	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[LHOL] C600 $
01m0006                               	                ;Check for XEND-of memory to be tested
01m0006 02203 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0006                               	                ;Set repeat count for this test and clear error we may
01m0006                               	                ;have gotten from running off the XEND-of memory
01m0006 02204 640710010571000430000000	T32:    D[MASK 43] DEST[AR] NORM $
01m0006                               	                ;Setup same thing to test against
01m0006 02205 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0006                               	                ;Start again from the beginning of memory
01m0006                               	                ;Also, fetch first word from memory
01m0006 02206 640710000171002440000000	T31:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0006                               	                ;Rotate test value by one and put it where we can
01m0006                               	                ;test with it easier
01m0006 02207 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0006                               	                ;Check the result of the examine against what was expected
01m0006                               	                ;and if no error, prepare to check ECC
01m0006 02210 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0006                               	         ;JMP if ECC err
01m0006 02211 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0006                               	                ;Advance to next location and start the examine
01m0006 02212 470140014537042010002206	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T31] C600 $
01m0006                               	                ;Check for the XEND-of memory.  Loop if not.
01m0006 02213 640243600571000440002204	        LOOP[T32] DEST[CLR-MI-ERR] NORM $
01m0006                               	                ;Repeat the examine phase N times.
01m0006                               	                ;(No more MA 18 jumper!!!)
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0006 02214 000300000571000440000000	        POPJ $
01m0006                               	LHOLX:
01m0007                               	]       TEST[01m0007 02215 640050010571000010002217	D[MASK 1] DEST[AR] PUSHJ[. + 2] NORM $
01m0007                               	                ;Setup thing to test with
01m0007 02216 000140000571000440000000	        JUMP[LBITX] $   ;Go to next test.
01m0007       7	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0007 02217 000041014571000073000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0007                               	          ;Put it where error typeouts can find it.
01m0007 02220 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0007                               	                ;Start at memory address 0
01m0007 02221 640714200571002440000000	LBIT:   D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0007                               	                ;Rotate test value and store new value in memory
01m0007                               	
01m0007 02222 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0007 02223 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0007 02224 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0007                               	                ;Check the result of the examine against what was expected
01m0007                               	                ;and if no error, prepare to check ECC
01m0007 02225 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0007                               	         ;JMP if ECC err
01m0007 02226 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0007                               	                ;Advance to next location
01m0007 02227 470140014537042010002221	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[LBIT] C600 $
01m0007                               	                ;Check for XEND-of memory to be tested
01m0007 02230 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0007                               	                ;Set repeat count for this test and clear error we may
01m0007                               	                ;have gotten from running off the XEND-of memory
01m0007 02231 640710010571000010000000	T42:    D[MASK 1] DEST[AR] NORM $
01m0007                               	                ;Setup same thing to test against
01m0007 02232 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0007                               	                ;Start again from the beginning of memory
01m0007                               	                ;Also, fetch first word from memory
01m0007 02233 640710000171002440000000	T41:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0007                               	                ;Rotate test value by one and put it where we can
01m0007                               	                ;test with it easier
01m0007 02234 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0007                               	                ;Check the result of the examine against what was expected
01m0007                               	                ;and if no error, prepare to check ECC
01m0007 02235 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0007                               	         ;JMP if ECC err
01m0007 02236 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0007                               	                ;Advance to next location and start the examine
01m0007 02237 470140014537042010002233	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T41] C600 $
01m0007                               	                ;Check for the XEND-of memory.  Loop if not.
01m0007 02240 640243600571000440002231	        LOOP[T42] DEST[CLR-MI-ERR] NORM $
01m0007                               	                ;Repeat the examine phase N times.
01m0007                               	                ;(No more MA 18 jumper!!!)
01m0007 02241 000300000571000440000000	        POPJ $
01m0007                               	LBITX:
01m0008                               	]       TEST[01m0008 02242 640050010571000220002244	D[MASK 22] DEST[AR] PUSHJ[. + 2] NORM $
01m0008                               	                ;Setup thing to test with
01m0008 02243 000140000571000440000000	        JUMP[HWDX] $    ;Go to next test.
01m0008       10	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0008 02244 000041014571000103000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0008                               	          ;Put it where error typeouts can find it.
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0008 02245 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0008                               	                ;Start at memory address 0
01m0008 02246 640714200571002440000000	HWD:    D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0008                               	                ;Rotate test value and store new value in memory
01m0008                               	
01m0008 02247 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0008 02250 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0008 02251 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0008                               	                ;Check the result of the examine against what was expected
01m0008                               	                ;and if no error, prepare to check ECC
01m0008 02252 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0008                               	         ;JMP if ECC err
01m0008 02253 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0008                               	                ;Advance to next location
01m0008 02254 470140014537042010002246	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[HWD] C600 $
01m0008                               	                ;Check for XEND-of memory to be tested
01m0008 02255 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0008                               	                ;Set repeat count for this test and clear error we may
01m0008                               	                ;have gotten from running off the XEND-of memory
01m0008 02256 640710010571000220000000	T52:    D[MASK 22] DEST[AR] NORM $
01m0008                               	                ;Setup same thing to test against
01m0008 02257 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0008                               	                ;Start again from the beginning of memory
01m0008                               	                ;Also, fetch first word from memory
01m0008 02260 640710000171002440000000	T51:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0008                               	                ;Rotate test value by one and put it where we can
01m0008                               	                ;test with it easier
01m0008 02261 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0008                               	                ;Check the result of the examine against what was expected
01m0008                               	                ;and if no error, prepare to check ECC
01m0008 02262 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0008                               	         ;JMP if ECC err
01m0008 02263 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0008                               	                ;Advance to next location and start the examine
01m0008 02264 470140014537042010002260	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T51] C600 $
01m0008                               	                ;Check for the XEND-of memory.  Loop if not.
01m0008 02265 640243600571000440002256	        LOOP[T52] DEST[CLR-MI-ERR] NORM $
01m0008                               	                ;Repeat the examine phase N times.
01m0008                               	                ;(No more MA 18 jumper!!!)
01m0008 02266 000300000571000440000000	        POPJ $
01m0008                               	HWDX:
01m0009                               	]       TEST[01m0009 02267 640050010571000150002271	D[MASK 15] DEST[AR] PUSHJ[. + 2] NORM $
01m0009                               	                ;Setup thing to test with
01m0009 02270 000140000571000440000000	        JUMP[T60X] $    ;Go to next test.
01m0009       11	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0009 02271 000041014571000113000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0009                               	          ;Put it where error typeouts can find it.
01m0009 02272 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0009                               	                ;Start at memory address 0
01m0009 02273 640714200571002440000000	T60:    D[AR] ROT[1] DEST[AR MEMSTO] NORM $
01m0009                               	                ;Rotate test value and store new value in memory
01m0009                               	
01m0009 02274 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0009 02275 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0009 02276 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0009                               	                ;Check the result of the examine against what was expected
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0009                               	                ;and if no error, prepare to check ECC
01m0009 02277 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0009                               	         ;JMP if ECC err
01m0009 02300 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0009                               	                ;Advance to next location
01m0009 02301 470140014537042010002273	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T60] C600 $
01m0009                               	                ;Check for XEND-of memory to be tested
01m0009 02302 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0009                               	                ;Set repeat count for this test and clear error we may
01m0009                               	                ;have gotten from running off the XEND-of memory
01m0009 02303 640710010571000150000000	T62:    D[MASK 15] DEST[AR] NORM $
01m0009                               	                ;Setup same thing to test against
01m0009 02304 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0009                               	                ;Start again from the beginning of memory
01m0009                               	                ;Also, fetch first word from memory
01m0009 02305 640710000171002440000000	T61:    D[AR] ROT[1] DEST[AR Q] NORM $
01m0009                               	                ;Rotate test value by one and put it where we can
01m0009                               	                ;test with it easier
01m0009 02306 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0009                               	                ;Check the result of the examine against what was expected
01m0009                               	                ;and if no error, prepare to check ECC
01m0009 02307 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0009                               	         ;JMP if ECC err
01m0009 02310 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0009                               	                ;Advance to next location and start the examine
01m0009 02311 470140014537042010002305	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[T61] C600 $
01m0009                               	                ;Check for the XEND-of memory.  Loop if not.
01m0009 02312 640243600571000440002303	        LOOP[T62] DEST[CLR-MI-ERR] NORM $
01m0009                               	                ;Repeat the examine phase N times.
01m0009                               	                ;(No more MA 18 jumper!!!)
01m0009 02313 000300000571000440000000	        POPJ $
01m0009                               	T60X:
01m0010                               	]       TESTC[01m0010 02314 640050010571000000002316	D[MASK 0] DEST[AR] PUSHJ[. + 2] NORM $
01m0010 02315 000140000571000440000000	        JUMP[C11X] $    ;Go to next test.
01m0010       12	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0010 02316 000041014571000123000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0010                               	          ;Put it where error typeouts can find it.
01m0010 02317 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0010 02320 640704200571000440000000	C11:    D[AR] DEST[MEMSTO] NORM $
01m0010                               	
01m0010 02321 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0010 02322 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0010 02323 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0010                               	                ;Check the result of the examine against what was expected
01m0010                               	                ;and if no error, prepare to check ECC
01m0010 02324 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0010                               	         ;JMP if ECC err
01m0010 02325 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0010 02326 470140014537042010002320	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[C11] C600 $
01m0010 02327 640743614571000100000000	        D[CONST 10] DEST[CLR-MI-ERR] LLOAD NORM $
01m0010 02330 640710010571000000000000	        D[MASK 0] DEST[AR] NORM $
01m0010 02331 640722600615000440000000	C13:    ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0010 02332 640700000171000440000000	C12:    D[AR] DEST[Q] NORM $
01m0010 02333 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0010 02334 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0010                               	         ;JMP if ECC err
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0010 02335 640704200771000440000000	        D[AR] ALU[NOTD] DEST[MEMSTO] NORM $
01m0010 02336 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0010 02337 470140014537042010002332	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[C12] C600 $
01m0010 02340 640710000771000440000000	        D[AR] ALU[NOTD] DEST[AR] NORM $
01m0010 02341 640243600571000440002331	        LOOP[C13] DEST[CLR-MI-ERR] NORM $
01m0010 02342 000300000571000440000000	        POPJ $
01m0010                               	C11X:
01m0011                               	]       TESTC[01m0011 02343 640050010571000220002345	D[MASK 22] DEST[AR] PUSHJ[. + 2] NORM $
01m0011 02344 000140000571000440000000	        JUMP[C21X] $    ;Go to next test.
01m0011       13	  TNUM = TNUM + 1  ;Increment test seq. no.
01m0011 02345 000041014571000133000000	        D[CONST TNUM] DEST[4] DEST-A-MEM PUSHJ[LDLTS1] $
01m0011                               	          ;Put it where error typeouts can find it.
01m0011 02346 640722600615000440000000	        ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0011 02347 640704200571000440000000	C21:    D[AR] DEST[MEMSTO] NORM $
01m0011                               	
01m0011 02350 640723624571000440000000	        D[MA] DEST[MA CLR-MI-ERR] NORM $
01m0011 02351 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0011 02352 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1X] C600 $
01m0011                               	                ;Check the result of the examine against what was expected
01m0011                               	                ;and if no error, prepare to check ECC
01m0011 02353 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1X] $
01m0011                               	         ;JMP if ECC err
01m0011 02354 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0011 02355 470140014537042010002347	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[C21] C600 $
01m0011 02356 640743614571000030000000	        D[CONST 3] DEST[CLR-MI-ERR] LLOAD NORM $
01m0011 02357 640710010571000220000000	        D[MASK 22] DEST[AR] NORM $
01m0011 02360 640722600615000440000000	C23:    ALU[0] DEST[MA HI-ABS-MA] NORM $
01m0011 02361 640700000171000440000000	C22:    D[AR] DEST[Q] NORM $
01m0011 02362 470040004735000443400000	        D[MEM] ALU[D#Q] COND[-OBUS=0] START-IN PUSHJ[ERR1] C600 $
01m0011 02363 030040030571036010020000	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERR1] $
01m0011                               	         ;JMP if ECC err
01m0011 02364 640704200771000440000000	        D[AR] ALU[NOTD] DEST[MEMSTO] NORM $
01m0011 02365 640722624033000440000000	        D[MA] ALU[D+1] DEST[Q MA HI-ABS-MA] NORM $
01m0011 02366 470140014537042010002361	        D[CONST NMEMS] ROT[17.] ALU[D-Q] COND[-OBUS=0] JUMP[C22] C600 $
01m0011 02367 640710000771000440000000	        D[AR] ALU[NOTD] DEST[AR] NORM $
01m0011 02370 640243600571000440002360	        LOOP[C23] DEST[CLR-MI-ERR] NORM $
01m0011 02371 000300000571000440000000	        POPJ $
01m0011                               	C21X:
01m0012 02372 640040014171000070000000	]       D[CONST 7] DEST[Q] PUSHJ[TYP] NORM $
01m0012                               	                ;Bells (and whistles???) at XEND of pass
01m0012                               	        TYPLET[01m0012 02373 640040014171000200000000	D[CONST 20] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"P"
01m0012 02374 640140000571000440002024	        JUMP[STRTLP] NORM $
01m0012                               	
01m0012                               	 .DEFINE GET1 01m0012                               	
01m0012 02375 000040100571000440000000	ERR1X:  CURRENTLY-UNUSED[1] PUSHJ[TTEST] $
01m0012                               	        TYPLET[01m0012 02376 640040014171000220000000	D[CONST 22] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"R"
01m0012 02377 000140000571000440000000	        JUMP[ERR1X1] $
01m0012                               	
01m0012 02400 000040100571000440000000	ERR1:   CURRENTLY-UNUSED[1] PUSHJ[TTEST] $
01m0012 02401 000040000571000440000000	ERR1X1: PUSHJ[ERR2] $
01m0012                               	
01m0012                               	 .REPEAT 2 [ 01m0012                               	;Now read the same location 2 more times, checking for errors.
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0012                               	        TYPLET[01m0012 02402 640040014171000030000000	D[CONST 03] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"C"
01m0012                               	        TYPSPC ;Type a <SPACE>
01m0012 02403 640040014171000400000000	        D[CONST 40] DEST[Q] PUSHJ[TYP] NORM ]$  ;<SPACE>
01m0012 02404 640720024571000440000000	        D[MA] DEST[MA] NORM $
01m0012 02405 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0012 02406 470040004735000440000000	        D[MEM] ALU[D#Q] COND[-OBUS=0] PUSHJ[ERR2] C600 $
01m0012                               	         ;Type out data errors.
01m0012                               	        GET1
01m0013 02407 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        D[IOD] MAPF[2] ROT[17] MASK[1]
01m0013 02410 030040030571036010020000	 COND[-OBUS=0] PUSHJ[ERR2] $
01m0013                               	         ;JMP if ECC err
01m0012                               	      ];Now read the same location 2 more times, checking for errors.
01m0012                               	        TYPLET[01m0012 02411 640040014171000030000000	D[CONST 03] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"C"
01m0012                               	        TYPSPC ;Type a <SPACE>
01m0012 02412 640040014171000400000000	        D[CONST 40] DEST[Q] PUSHJ[TYP] NORM ]$  ;<SPACE>
01m0012 02413 640720024571000440000000	        D[MA] DEST[MA] NORM $
01m0012 02414 640700000171000440000000	        D[AR] DEST[Q] NORM $
01m0012 02415 470040004735000440000000	        D[MEM] ALU[D#Q] COND[-OBUS=0] PUSHJ[ERR2] C600 $
01m0012                               	         ;Type out data errors.
01m0012                               	        GET1
01m0013 02416 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        D[IOD] MAPF[2] ROT[17] MASK[1]
01m0013 02417 030040030571036010020000	 COND[-OBUS=0] PUSHJ[ERR2] $
01m0013                               	         ;JMP if ECC err
01m0012 02420 000040000571000440000000	      ] PUSHJ[TCR] $  ;Type CRLF
01m0012 02421 000040000571000440000000	        PUSHJ[LDLTS] $ ; Display bad data in lites.
01m0012 02422 000140000571000440000000	        JUMP[SWLOOP] $
01m0012                               	                ;Call SWLOOP to test switches for what to do next.
01m0012 02423 000301614571000013400000	SWCONT: START-IN D[CONST 1] DEST[DEV-ADR] POPJ $
01m0012                               	          ;Go back to test if we return from SWLOOP.
01m0012                               	                ;START-IN may be needed by test we are returning to.
01m0012                               	
01m0012                               	ERRSW:  TYPLET[01m0012 02424 640040014171000230000000	D[CONST 23] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"S"
01m0012                               	        TYPLET[01m0012 02425 640040014171000270000000	D[CONST 27] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"W"
01m0012                               	        TYPSPC ;Type a <SPACE>
01m0012 02426 640040014171000400000000	        D[CONST 40] DEST[Q] PUSHJ[TYP] NORM ]$
01m0012                               	
01m0012                               	ERR2:     ; TYPE MA & AR
01m0012 02427 640040024171000440000000	        D[MA] DEST[Q] PUSHJ[NTYP] NORM $
01m0012 02430 640040000171000440000000	        D[AR] DEST[Q] PUSHJ[NTYP] NORM $
01m0012                               	        GET1
01m0013 02431 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        D[IOD] MAPF[2] ROT[17] MASK[1]
01m0013 02432 030140030571036010020000	 COND[-OBUS=0] JUMP[ERR3] $
01m0013                               	         ;j if ECC ERR
01m0013 02433 640040014171002470000000	        D[CONST 47] ROT[1] DEST[Q] PUSHJ[TYP] NORM $
01m0013                               	         ; prnt N
01m0013 02434 640040014033002420000000	        D[CONST 42] ROT[1] ALU[D+1] DEST[Q] PUSHJ[TYP] NORM $
01m0013                               	         ; prnt E
01m0013                               	        TYPSPC ;Type a <SPACE>
01m0013 02435 640040014171000400000000	        D[CONST 40] DEST[Q] PUSHJ[TYP] NORM ]$
01m0013 02436 640140000571000440000000	        JUMP[NERR1] NORM $
01m0013                               	ERR3:    ; Type ECC stuff
01m0013 02437 640040014033002420000000	        D[CONST 42] ROT[1] ALU[D+1] DEST[Q] PUSHJ[TYP] NORM $; PRINT E
01m0013 02440 640700014171000400000000	        D[CONST 40] DEST[Q] NORM $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0013                               	        GET1
01m0014 02441 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        D[IOD] MAPF[4] ROT[40] MASK[1]
01m0014 02442 010140030571100010042444	 COND[OBUS=0] JUMP[. + 2] $; HARD ERR?
01m0014 02443 640700014035000500000000	        D[CONST 50] ALU[D+Q] DEST[Q] NORM $
01m0014 02444 640040000571000440000000	        PUSHJ[TYP] NORM $
01m0014                               	        GET1
01m0015 02445 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        MAPF[2] D[IOD] ROT[16] MASK[6] DEST[Q]
01m0015 02446 240040030171034060020000	 PUSHJ[NTYP] C800 $
01m0015                               	        GET1
01m0016 02447 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        MAPF[2] D[IOD] MASK[20.] DEST[Q] C800 $
01m0016 02450 240700030171000240020000	
01m0016 02451 450300024735000440000000	        D[MA] ALU[D#Q] COND[OBUS=0] POPJ C600 $
01m0016 02452 640040014033002460000000	        D[CONST 46] ROT[1] ALU[D+1] DEST[Q] PUSHJ[TYP] NORM $
01m0016                               	        GET1
01m0017 02453 640701614571000013400000	[CONST 1] DEST[DEV-ADR] START-IN NORM $]        MAPF[2] D[IOD] MASK[20.] DEST[Q]
01m0017 02454 240040030171000240020000	 PUSHJ[NTYP] C800 $
01m0017 02455 640703604171000440000000	NERR1:  D[MEM] DEST[Q CLR-MI-ERR] SHORT $
01m0017 02456 640701614571000010000000	        D[CONST 1] DEST[DEV-ADR] NORM $
01m0017 02457 510300000735000443400000	        START-IN D[AR] ALU[D#Q] C550  OBUS=0 POPJ $
01m0017                               	         ;Don't type data from memory unless it is in error.
01m0017 02460 640040004171000440000000	        D[MEM] DEST[Q] PUSHJ[NTYP] NORM $
01m0017                               	         ; Type erroneous data.
01m0017 02461 640301614571000013400000	        START-IN D[CONST 1] DEST[DEV-ADR] NORM POPJ $
01m0017                               	         ;Start reading ECC bits for routine we may be returning to.
01m0017                               	
01m0017 02462 640704460571000440000000	LDLTS1: D[14] DEST[HOLD] NORM $
01m0017                               	
01m0017 02463 640701600615000440000000	LDLTS:  ALU[0] DEST[DEV-ADR] NORM $     ;Prepare to set lights
01m0017 02464 640702204571000443600000	        D[MEM] DEST[IOD] SPEC[IOB-OUT] NORM $   ;Display what we read
01m0017 02465 000700004571000440000000	        D[MEM] $ ;At least some machines use OBUS for this.
01m0017 02466 640301614571000010000000	        D[CONST 1] DEST[DEV-ADR] NORM POPJ $
01m0017                               	
01m0017                               	SWLOOP:  ;Examine the CONSOLE SWITCHES to determine next action.
01m0017                               	         ;Current (1/18/81) options:
01m0017                               	        ;EXAMINE, DEPOSIT -- work as in regular microcode.
01m0017                               	        ;CONT -- proceed with current test
01m0017                               	        ;RESET -- jump to next test
01m0017                               	        ;START -- re-start MEMTST
01m0017                               	
01m0017 02467 640701600615000440000000	        ALU[0] DEST[DEV-ADR] NORM $
01m0017                               	         ;First we save the AR.
01m0017 02470 640701200571000443000000	        D[AR] DEST[5] DEST-A-MEM NORM $
01m0017 02471 640701400571000443000000	        D[AR] DEST[6] DEST-A-MEM NORM $
01m0017                               	         ;Init the Switch Compare Data to the current test data.
01m0017 02472 640700000571000443600000	        START-OUT NORM $
01m0017 02473 440700000571000440040000	        MAPF[4] CYLEN[IOB-OUT] $        ;CLR SW FF'S
01m0017 02474 640700000571000443400000	        START-IN NORM $
01m0017 02475 240710030571000440040000	STPLP1: D[IOD] DEST[AR] MAPF[4] C800 $  ;GET SW BITS
01m0017 02476 530140000571020010000000	        D[AR] ROT[10] MASK[1] COND[-OBUS=0] JUMP[RESW2] C550 $  ;J IF RESET SW
01m0017 02477 640700000171030110000000	        D[AR] ROT[14] MASK[11] DEST[Q] NORM $
01m0017 02500 450140014675010073402475	        D[CONST 7] ROT[4] ALU[-D&Q] COND[OBUS=0] START-IN JUMP[STPLP1] C600 $
01m0017                               	                ; LOOP IF NO SW
01m0017 02501 640700000571000443600000	        SPEC[IOB-OUT] NORM $
01m0017 02502 440700000571000440040000	        MAPF[4] CYLEN[IOB-OUT] $        
01m0017                               	                ;CLR SW FF'S
01m0017                               	  .DEFINE SWTEST 01m0017                               	NORSW2: SWTEST[SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0017 02503 530140000571010010000000	D[AR] ROT[4] MASK[1] COND[-OBUS=0] JUMP [ CONSW ] C550 $
01m0018                               	       ]        SWTEST[01m0018 02504 530140000571012010000000	D[AR] ROT[5] MASK[1] COND[-OBUS=0] JUMP [ STRTSW ] C550 $
01m0019                               	       ]        SWTEST[01m0019 02505 530140000571022010000000	D[AR] ROT[11] MASK[1] COND[-OBUS=0] JUMP [ DEPTSW ] C550 $
01m0020                               	       ]        SWTEST[01m0020 02506 530140000571024010000000	D[AR] ROT[12] MASK[1] COND[-OBUS=0] JUMP [ DEPNSW ] C550 $
01m0021                               	       ]        SWTEST[01m0021 02507 530140000571026010000000	D[AR] ROT[13] MASK[1] COND[-OBUS=0] JUMP [ EXMTSW ] C550 $
01m0022                               	       ]        SWTEST[01m0022 02510 530140000571030010000000	D[AR] ROT[14] MASK[1] COND[-OBUS=0] JUMP [ EXMNSW ] C550 $
01m0023 02511 640141614571000003402475	       ]NORSWR: D[CONST 0] DEST[DEV-ADR] START-IN JUMP[STPLP1] NORM $   ;LOOP
01m0023                               	
01m0023 02512 640700000571000443400000	RESW2:  START-IN SHORT $
01m0023 02513 240710030571000440000000	        D[IOD] DEST[AR]  C800 $ ;DOUBLE CHECK RESET SW
01m0023 02514 250140000571020010002503	        D[AR] ROT[10] MASK[1] COND[OBUS=0] JUMP[NORSW2] C800 $
01m0023 02515 000340000571000440002423	        JPOP[SWCONT] $ ;Return up-level to skip to next test.
01m0023                               	
01m0023 02516 000340000571000440002517	STRTSW: JPOP[. + 1] $
01m0023                               	         ;Clear stack and restart
01m0023 02517 000340000571000440002520	        JPOP[. + 1] $
01m0023 02520 000340000571000440002521	        JPOP[. + 1] $
01m0023 02521 000340000571000440002000	        JPOP[2000] $
01m0023                               	
01m0023 02522 000713664571000440000000	CONSW:  D[15] DEST[AR CLR-MI-ERR]  $
01m0023 02523 000141614571000010002423	        D[CONST 1] DEST[DEV-ADR] JUMP[SWCONT] $
01m0023                               	         ;Restore AR and DEV-ADR and continue.
01m0023                               	
01m0023 02524 640162600571000233400000	DEPTSW: D[AR] MASK[23] DEST[MA HI-ABS-MA] START-IN JUMP[DEPSW1] NORM $
01m0023 02525 640720024433000443400000	DEPNSW: D[MA] ALU[D+1] DEST[MA] NORM START-IN $
01m0023 02526 240714230571000440020000	DEPSW1: D[IOD] DEST[AR MEMSTO] MAPF[2] C800 $
01m0023 02527 640701400571000443000000	        D[AR] DEST[6] DEST-A-MEM NORM $ 
01m0023                               	          ;Update the Switch Compare Data.
01m0023 02530 000143600571000440002511	        DEST[CLR-MI-ERR] JUMP[NORSWR] $
01m0023                               	
01m0023 02531 640162600571000230000000	EXMTSW: D[AR] MASK[23] DEST[MA HI-ABS-MA] JUMP[EXMSW1] NORM $
01m0023 02532 640162624433000440000000	EXMNSW: D[MA] ALU[D+1] DEST[MA HI-ABS-MA] JUMP[EXMSW1] NORM $
01m0023                               	
01m0023 02533 640710064171000443600000	EXMSW1: SPEC[IOB-OUT] D[15] DEST[Q AR] NORM $
01m0023 02534 000700004571000440020000	        D[MEM] MAPF[2] $
01m0023                               	         ;Put mem data into data lites.
01m0023 02535 000710070571000440000000	        D[16] DEST[AR] $
01m0023                               	         ;Get Switch Compare Data for error routines.
01m0023 02536 640701614571000013400000	        GET1 [CONST 1] DEST[DEV-ADR] START-IN NORM $]  ;Test for ECC error.
01m0023 02537 030040030571036010022424	        D[IOD] MAPF[2] ROT[17] MASK[1] COND[-OBUS=0] PUSHJ[ERRSW] $
01m0023                               	         ;JMP if ECC err
01m0023 02540 640141600615000440002511	        ALU[0] DEST[DEV-ADR] NORM JUMP[NORSWR] $
01m0023                               	
01m0023 02541 640700000171000270000000	BRPNT:  D[AR] MASK[27] DEST[Q] NORM $
01m0023 02542 470140020537000270002522	        D[PC] MASK[27] ALU[D-Q] COND[-OBUS=0] JUMP[CONSW] C600 $
01m0023 02543 640140000571000443402475	        START-IN JUMP[STPLP1] NORM $
01m0023                               	
01m0023 02544 640040014171000150000000	TCR:    D[CONST 15] DEST[Q] PUSHJ[TYP] NORM $
01m0023 02545 640703600571000440000000	        DEST[CLR-MI-ERR] NORM $
01m0023 02546 640040014171000120000000	        D[CONST 12] DEST[Q] PUSHJ[TYP] NORM $
01m0023 02547 640301614571000013400000	        D[CONST 1] DEST[DEV-ADR] START-IN POPJ NORM $
01m0023                               	
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- MEMT1

01m0023                               	TTEST:  TYPLET[01m0023 02550 640040014171000240000000	D[CONST 24] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"T"
01m0023                               	        TYPLET[01m0023 02551 640040014171000050000000	D[CONST 05] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"E"
01m0023                               	        TYPLET[01m0023 02552 640040014171000230000000	D[CONST 23] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"S"
01m0023                               	        TYPLET[01m0023 02553 640040014171000240000000	D[CONST 24] DEST[Q] PUSHJ[LTYP] NORM ]$ ;"T"
01m0023 02554 000701614571000010000000	        D[CONST 1] DEST[DEV-ADR] $
01m0023                               	         ;Get number of current test, and type it out.
01m0023 02555 000140060171000440000000	        D[14] DEST[Q] JUMP[NTYP] $
01m0023                               	
01m0023                               	
01m0023                               	NTYP:    ;Type Q as an octal integer (leading-zero-suppressed) -- save AR
01m0023                               	         ; Type a space after the number.
01m0023 02556 640700001571400440000000	        ACSEL[AC+1] D[AR] DEST[AC] NORM $
01m0023 02557 640700015571000140000000	        D[CONST 12.] DEST[AC] NORM $
01m0023                               	         ;Max. no. of digits
01m0023 02560 640710000555000440000000	        ALU[Q] DEST[AR] NORM $
01m0023                               	NTL1:    ;Skip up to 11. leading 0's
01m0023 02561 640710000571006440000000	        D[AR] ROT[3] DEST[AR] NORM $
01m0023 02562 470140000171000030000000	        D[AR] MASK[3] DEST[Q] COND[-OBUS=0] JUMP[NTL2] C600 $
01m0023 02563 470140001451000440002561	        ALU[AC-1] DEST[AC] COND[-OBUS=0] JUMP[NTL1] C600 $
01m0023 02564 640040014171000600000000	        D[CONST 60] DEST[Q] PUSHJ[TYP] NORM $
01m0023                               	         ;Type the 12th leading 0 and exit.
01m0023 02565 640040014171000400000000	NTL3:   D[CONST 40] DEST[Q] PUSHJ[TYP] NORM $
01m0023                               	         ;Type a space before exiting.
01m0023 02566 640310000551400440000000	        ACSEL[AC+1] ALU[AC] DEST[AR] POPJ NORM $
01m0023                               	NTL2:    ;Type the significant digits.
01m0023 02567 640040014175000600000000	        D[CONST 60] ALU[DORQ] DEST[Q] PUSHJ[TYP] NORM $
01m0023 02570 450140001451000440002565	        ALU[AC-1] DEST[AC] COND[OBUS=0] JUMP[NTL3] C600 $
01m0023                               	         ;Exit if 12th digit has been typed.
01m0023 02571 640710000571006440000000	        D[AR] ROT[3] DEST[AR] NORM $
01m0023                               	         ;Get next digit.
01m0023 02572 640140000171000030002567	        D[AR] MASK[3] DEST[Q] JUMP[NTL2] NORM $
01m0023                               	
01m0023                               	 ; TYPE OUT CHR IN Q -- saves AR, clobbers IR-ADR
01m0023 02573 640701614571000040000000	TYP:    D[CONST 4] DEST[DEV-ADR] NORM $
01m0023 02574 640700000571000443400000	        START-IN NORM $
01m0023 02575 240704630571000440000000	        D[IOD] DEST[PC] C800 $
01m0023 02576 410140020571052010002573	        D[PC] ROT[25] MASK[1] COND[OBUS=0] JUMP[TYP] CYLEN[C650] $
01m0023                               	         ; wait for rdy
01m0023 02577 640700214571014400000000	        D[CONST 40] ROT[6] DEST[IR-ADR] NORM $
01m0023 02600 030140234531000220002600	        D[IR] MASK[22] ALU[D-1] DEST[IR-ADR] COND[-OBUS=0] JUMP[.] $
01m0023                               	 .DEFINE TOUT 01m0023                               	        TOUT 01m0023 02601 640702214555000003600000	D[CONST 0] ALU[Q] DEST[IOD] SPEC[IOB-OUT] NORM $
01m0023 02602 440700000571000440120000	        MAPF[TTY.WD] CYLEN[IOB-OUT] $
01m0024                               	]       TOUT 01m0024 02603 640702214571000753600000	D[CONST 75] ALU[D] DEST[IOD] SPEC[IOB-OUT] NORM $
01m0024 02604 440700000571000440140000	        MAPF[TTY.WC] CYLEN[IOB-OUT] $
01m0025                               	]       TOUT 01m0025 02605 640702214571000743600000	D[CONST 74] ALU[D] DEST[IOD] SPEC[IOB-OUT] NORM $
01m0025 02606 440700000571000440140000	        MAPF[TTY.WC] CYLEN[IOB-OUT] $
01m0026 02607 640700214571014400000000	]       D[CONST 40] ROT[6] DEST[IR-ADR] NORM $
01m0026 02610 030140234531000220002610	        D[IR] MASK[22] ALU[D-1] DEST[IR-ADR] COND[-OBUS=0] JUMP[.]  $
01m0026 02611 640300000571000440000000	        POPJ NORM $
SLOE   Jan ***, 1859 00:00:03  file DSK:MEMTST.SLO  --  of -- MEMT1

01m0026                               	;Type a letter (add 100 and call TYP)
01m0026 02612 000140014035014010002573	LTYP:   D[CONST 1] ROT[6] ALU[D+Q] DEST[Q] JUMP[TYP] $
01m0026                               	
01m0026                               	: 0
01m0026                               	
01m0026 00000 000140000571000440002000	        JUMP[2000]  $  ;Starting addres for bootstrapper
01m0026                               	

SLOE   Jan ***, 1859 00:00:03  file DSK:MEMT1.SLO  --  of -- MEMT1

%Warn    no-@  is an undefined label 
