Article 693 of rec.games.corewar:
From: Scott_-_Nelson@cup.portal.com
Newsgroups: rec.games.corewar
Subject: warriors
Message-ID: <56725@cup.portal.com>
Date: Wed,  1 Apr 92 01:31:40 PST
Organization: The Portal System (TM)
Lines: 110

    One more warrior from my collection, Molerat.
Molerat is a variant on Lemmings (see TCWN, spring 1988, page 11)
It won the 1990 ICWS tourney and took second in the Grand finally
held just afterward.
 
  It is not easy to follow the code, so I will outline the basic
flow.  
    Start 5 processes running inline (all 5 executing the same instructions)
    split to one of two "types", add or sub (more on this later)
 
    type add ;
      adds 5 locations to another location
      makes a copy of itself,
      splits to the beginning and repeats -and/or-
      bombs the location pointed to by the adds (perhaps a slave pit?)
      jumps to the copy.
 
    type sub ;
      subtracts 5 locations from another location
      makes a copy of itself,
      splits to the beginning and repeats -and/or-
      bombs the location pointed to by the subtracts (perhaps a slave pit?)
      jumps to the copy.
 
----- cut -----
;redcode
;name Molrat A.K.A paper
;author Scott Nelson
;strategy - Replicate -
 
start
; start up five inline process
	spl	1
	mov	-1,	0
	mov	-1,	0
	spl	paper4		;type add
	spl	paper3		;type sub
	spl	paper2		;type add
	jmp	paper1		;type sub
count	dat		#5
 
src1	mov	#10,	10	;initialize src for copy
	sub	<203,	204	;subtract for pit-bombing 
paper1	mov	<src1,	<dest1	;copy five locations
	mov	<src1,	<dest1	;copy five more
	spl	back1		;if we can, make more copies
	mov	bomb1,	<200	;bomb the pit (we hope)
dest1	jmz	@dest1,	6101	;if copy worked, jump there
back1	jmz	src1,	src1	;if copy worked, split back
	mov	0,	-1	;hmm . . . something went wrong, try to die.
bomb1	dat		#-10	;die
;
	dat		#1	
	dat		#1
	dat		#1
;
src2	mov	#10,	10
	add	<203,	204
paper2	mov	<src2,	<dest2
	mov	<src2,	<dest2
	spl	back2
	mov	bomb2,	<200
 
dest2	jmz	@dest2,	6301
back2	jmz	src2,	src2
	mov	0,	-1
bomb2	dat		#-10
	dat		#1
	dat		#1
	dat		#1
 
	mov	#10,	10
	sub	<203,	204
paper3	mov	<-2,	<4
	mov	<-3,	<3
	spl	3
	mov	4,	<200
	jmz	@0,	6501
	jmz	-7,	-7
	mov	0,	-1
	dat		#-10
	dat		#1
	dat		#1
	dat		#1
 
	mov	#10,	10
	add	<203,	204
paper4	mov	<-2,	<4
	mov	<-3,	<3
	spl	3
	mov	4,	<200
	jmz	@0,	6701
	jmz	-7,	-7
	mov	0,	-1
	dat		#-10
	end	start 
----- end cut ----- 
 
    Notes:  Molerat's major strength lies in the total lack of loops.  It
can (and does) spend 50% of its time modifying memory.  It is also
very good at dying when modified. (Alas, it is not perfect at it.) 
At first this might seem like a bad thing, but if a copy dies
(instead of being trapped in slave pit) then another (presumably
unmodified) Molerat can be born.  It also avoids the problem of the
enemy becoming a Molerat, since exactly five processes would have to
be executing inline in order to become a Molerat.  It also handles
SPL 0 bombs fairly well, since it consumes processes five times
faster than most mice-like programs.
    It is worth noting that Molerat performs better with a larger
coresize.  In fact in a large enough core, Molerat will beat XTC.