;name rep-phage
;assert 1 


deltap		equ  	(CORESIZE/4)				
PORT0		equ	(port0)
PORT1		equ	(port0+deltap)
PORT2		equ	(port0+2*deltap)
PORT3		equ	(port0+3*deltap)

optima 		equ	73

confidence	equ	10

gap		equ 	2*deltap-port0

port0		DAT	#0,			#0	

for 700
		DAT	#0,			#0
rof 

attack		DAT	#0,			#0
	
first		DAT	#0,			#last-first

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

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

		MOV	zero,			PORT0		
		MOV	zero,			PORT1
		MOV	zero,			PORT2
		MOV	zero,			PORT3
		MOV	zero,			PORT0		
		MOV	zero,			PORT1
		MOV	zero,			PORT2
		MOV	zero,			PORT3

		DJN	loopb,			boot
				
;hand-shake 	
		MOV	#last-first,		first
loop0		MOV	@first,			@ploc
		XCH	@ploc,			@ploc
		JMP	@ploc,			move 
return		DJN	loop0,			first
			
;replicate  
		SPL	@ploc,			begin

		MOV.B   ploc,                   oldploc
                ADD     #ploc-oldploc,          oldploc
		MOV	#0,			modulestart

;new port    	
next	 	ADD	#deltap,		ploc
		ADD	#deltap,		ploc2 
	
		SUB	deltapA,		dat2
		SUB	#deltap,		dat3
		ADD	deltapA,		dat3
		SUB	#deltap,		dat4	

		MOV	zero,			PORT0		
		MOV	zero,			PORT1
		MOV	zero,			PORT2
		MOV	zero,			PORT3		
		MOV	zero,			PORT0		
		MOV	zero,			PORT1
		MOV	zero,			PORT2
		MOV	zero,			PORT3

		JMP	check
		

deltapA		DAT	#deltap,		#0

set		DAT	#0,			#0


;'88 launch code
boot		DAT	#0,			#mov1
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 



;viral module 
module		ADD	#optima,		attack
		JMZ.B	module,			@attack
		NOP	0,			0
		NOP	0,			0
modulestart	JMN	modulecont,		#1 
		SPL	@oldploc,		module
modulesplit	MOV	#1,			modulestart
modulecont	SLT	#start-attack,		attack
		JMP	module
moduleloop	JMN.B	moduleloop,		<attack

modulebverify	NOP	@attack,		#1
		SCC	>attack
oldploc		JMP	moduleverify,		#0

modulekill	MOV	zero,			@attack
		JMN.B	modulekill,		>attack
		MOV	#confidence,		moduleverify
		JMP	module

moduleverify	DJN	modulebverify,		#confidence
		SUB.BA	attack,			@attack
		ADD	moduleinit,		@attack
		JMN	0,			modulestart
		SPL	@oldploc,		module
		JMP	modulesplit

moduleinit	DAT	#module-attack,		#10
				
move		MOV	@ploc,			<launch
last		JMP	@ploc,	 		return

; not copied  
ploc		DAT	#0,			#port0
ploc2		DAT	#0,			#0
launch		DAT	#0,			#last

start 		SCS 	set
		NOP	0
		MOV	set,			first
		SPL	module
		JMP	begin
 

		end 	start