;name rep-retry
;assert 1

deltap		equ  	CORESIZE/4				
optima		equ	73

delay		equ	4
longdelay	equ	200

gap		equ 	2*deltap-port0

port0		DAT	#0,			#0	

for 300
		DAT	#0,			#0
rof		

attack		DAT	#0,			#0
wipe		DAT	#0,			#0

first		DAT	#0,			#last-first
second		DAT	#0,			#last-second

;self-wipe		
initwipe	MOV	#last-wipe,		wipe
wipeloop	MOV	zero,			<wipe
		MOV	zero,			<wipe
		JMP	wipeloop

lock		DAT	#0,			#0

;initialize 
begin		MOV	#port0-ploc,		ploc	
		MOV	#2*deltap+port0-ploc2,	ploc2
		MOV	zero,			dat2
		MOV	zero,			dat3
		MOV	zero,			dat4
		MOV	zero,			attack
	
;check (and set) the lock 
check		SCS	@ploc,			lock
		JMP	next		

;boot 			
adjustb		MOV	#mov1-boot,		boot 	
loopb		MOV	@boot,			@ploc
		ADD	<boot,			@ploc
		XCH	@ploc,			@ploc
		SPL	@ploc,			@ploc2	
		DJN	loopb,			boot

;hand-shake 
		MOV	#last-first,		first
		MOV	@first,			@ploc
		XCH	@ploc,			@ploc
		SPL	@ploc,			move
		MOV	#delay,			spin

;defend & attack 
loop	 	ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack	
		SLT	first,			#last-first
		DJN	loop,			spin
		JMZ	adjustb,		spin 		

;self-test during write  
		MOV	#last-second,		second
		MOV	zero,			sum
		MOV	#loop1-gate,		gate
test		ADD	@second,		sum		
		DJN	test,			second
		SUB	dat2,			sum
		SUB	dat3,			sum
		SUB	dat4,			sum
		CMP	zero,			sum	
	 	JMP	initwipe

;passed self-test 
		MOV	#longdelay,		spin1
;defend & attack 
loop1		ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack		
		DJN	@gate,			spin1		
		JMP	adjustb

;replicate 
replicate	SPL	@ploc,			begin

;new port    	
next		
		MOV	zero,			@ploc
		MOV	zero,			@ploc2

		ADD	#deltap,		ploc
		ADD	#deltap,		ploc2 

		MOV	zero,			@ploc
		MOV	zero,			@ploc2
	
		SUB	deltapA,		dat2
		SUB	#deltap,		dat3
		ADD	deltapA,		dat3
		SUB	#deltap,		dat4

;defend & attack 
 		ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack
 		ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack
 		ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack
		ADD	#optima,		attack
		SLT	attack,			#start-attack
		MOV	lock,			@attack

		JMP	check		

expected	DAT	#0,			#0

;async write   
loop0		MOV	@first,			@ploc
		XCH	@ploc,			@ploc
		JMP	@ploc,			move 
return		MOV	zero,			@ploc2		
		DJN	loop0,			first
	
		MOV	#replicate-gate,	gate
		
deltapA		DAT	#deltap,		#0

;'88 launch code
boot		DAT	#0,			#0
zero		DAT	#0,			#0
		MOV	@ploc-move,		<launch-move
dat4		DAT	#0,			#0
		MOV	#last-launch+1,		gap+launch
dat3		DAT	#0,			#0
		MOV	#2*deltap+port0-ploc,	gap+ploc 
dat2		DAT	#0,			#0
		MOV	#2*move+gap-launch+1,	launch-move
dat1		DAT	#0,			#0
mov1		MOV	#move-ploc,		ploc-move 

move		MOV	@ploc,			<launch
last		JMP	@ploc,	 		return

; not copied  
ploc		DAT	#0,			#port0
ploc2		DAT	#0,			#0
launch		DAT	#0,			#last
spin		DAT	#0,			#delay
spin1 		DAT	#0,			#longdelay
sum		DAT	#0,			#0
gate		DAT	#0,			#loop0 

start 		MOV	#last-second,		second
init		ADD	@second,		sum
		DJN	init,			second 
		SUB	sum,			expected
		SCS 	lock
		JMP	begin
		JMP	begin

		end 	start