anchor.diff:   4 const, /node
    3 const, roundup
   
  -int, poolbase
  +int, mplsta
  +int, mplsiz
  +
  +:, fmtmem
  +	mplsta @, mplsta @, !,
  +	mplsiz @, -/node and, -/node +, mplsta @, 2 #, +, !,  ;,
  +
  +\ getmem allocates a block of memory from a formatted memory pool.  The mplsta
  +\ variable must point to the pool to allocate from.
  +
   int, p
  -
  -sub: fmtmem
  -	1 +fp@, 1 +fp@, !,
  -	2 +fp@, -/node and, -/node +, 1 +fp@, 2 #, +, !,
  +int, q
  +
  +int, memptr
  +int, memsiz
  +
  +:, gm2
  +	memptr @, /node +, memsiz @, +, p !,  memptr @, @,  p @, !,
  +	memptr @, /node +, memsiz @, +,   memptr @, !,
  +	memsiz @, /node +, -1 #, xor, 1 #, +,  memptr @, 2 #, +, @, +,  memptr @, @, 2 #, +, !,
  +	memsiz @, 1 #, xor, memptr @, 2 #, +, !,
  +	memptr @, /node +, memptr !,  0 #, rsn !,
   	rfs,
   
  -\ getmem allocates a block of memory from a formatted memory pool.  The poolbase
  -\ variable must point to the pool to allocate from.
  -\ Arguments:
  -\	+0	Return PC
  -\	+1	Size to allocate, in bytes
  -\ If successful, it returns:
  -\	+2	Pointer to allocated block of memory
  -\	+3	0
  -\ Otherwise:
  -\	+2	undefined
  -\	+3	non-zero reason code.
  -
  -:, gm2
  -	-1 +fp@, /node +, 1 +fp@, +, p !,  -1 +fp@, @,  p @, !,
  -	-1 +fp@, /node +, 1 +fp@, +,   -1 +fp@, !,
  -	1 +fp@, /node +, -1 #, xor, 1 #, +,  -1 +fp@, 2 #, +, @, +,  -1 +fp@, @, 2 #, +, !,
  -	1 +fp@, 1 #, xor, -1 +fp@, 2 #, +, !,
  -	-1 +fp@, /node +, 2 +fp!,  0 #, 3 +fp!,
  +:, gmCombine
  +	memptr @, @, 2 #, +, @, 1 #, and, if, exit, then,
  +	memptr @, @, mplsta @, xor, if,
  +		memptr @, 2 #, +, q !,
  +		memptr @, @, 2 #, +, @, /node +, q @, @, +, q @, !,
  +		memptr @, @, @, memptr @, !,
  +	then, ;,
  +
  +:, gm1
  +	memptr @, 2 #, +, @, 1 #, and,
  +	if,	memptr @, @, memptr !,
  +		memptr @, mplsta @, xor, if, again, then,
  +		0 #, memptr !,  ESIZE $100 #, +, rsn !, rfs,
  +	then,
  +
  +	gmCombine
  +
  +	memptr @, 2 #, +, @, q !,
  +
  +	memsiz @,  -1 #, xor, 1 #, +,  q @, +,  $8000 #, and,
  +	if,	memptr @, @, memptr !,
  +		memptr @, mplsta @, xor, if, again, then,
  +		0 #, memptr !,  ESIZE $500 #, +, rsn !, rfs,
  +	then,
  +
  +	/node /node +, memsiz @, +, -1 #, xor, 1 #, +,  q @, +, $8000 #, and, $8000 #, xor,
  +	if,	gm2
  +	then,
  +
  +	q @, 1 #, xor, memptr @, 2 #, +, !,
  +	memptr @, /node +, memptr !,  0 #, rsn !,
  +	rfs, ;,
  +
  +sub: getmem
  +	mplsta @,
  +	if,	mplsta @, memptr !,
  +		memsiz @, roundup +, -/node and, memsiz !,
  +		gm1
  +	then,
  +	0 #, memptr !,  EBASE rsn !,
   	rfs,
   
  -:, gmCombine
  -	-1 +fp@, @, 2 #, +, @, 1 #, and, if, exit, then,
  -	-1 +fp@, @, poolbase @, xor, if,
  -		-1 +fp@, 2 #, +, -3 +fp!,
  -		-1 +fp@, @, 2 #, +, @, /node +, -3 +fp@, @, +, -3 +fp@, !,
  -		-1 +fp@, @, @, -1 +fp@, !,
  -	then, ;,
  -
  -:, gm1
  -	-1 +fp@, 2 #, +, @, -2 +fp!,
  -
  -	-2 +fp@,  1 #, and,
  -	if,	-1 +fp@, @, -1 +fp!,
  -		-1 +fp@, poolbase @, xor, if, again, then,
  -		0 #, 2 +fp!,  ESIZE $100 #, +, 3 +fp!, rfs,
  -	then,
  -
  -	gmCombine
  -
  -	-1 +fp@, 2 #, +, @, -2 +fp!,
  -
  -	1 +fp@,  -1 #, xor, 1 #, +,  -2 +fp@, +,  $8000 #, and,
  -	if,	-1 +fp@, @, -1 +fp!,
  -		-1 +fp@, poolbase @, xor, if, again, then,
  -		0 #, 2 +fp!,  ESIZE $500 #, +, 3 +fp!, rfs,
  -	then,
  -
  -	/node /node +, 1 +fp@, +, -1 #, xor, 1 #, +,  -2 +fp@, +, $8000 #, and, $8000 #, xor,
  -	if,	gm2
  -	then,
  -
  -	-2 +fp@, 1 #, xor, -1 +fp@, 2 #, +, !,
  -	-1 +fp@, /node +, 2 +fp!,  0 #, 3 +fp!,
  -	rfs, ;,
  -
  -sub: getmem
  -	poolbase @,
  -	if,	poolbase @, -1 +fp!,
  -		1 +fp@, roundup +, -/node and, 1 +fp!,
  -		gm1
  -	then,
  -	0 #, 2 +fp!,  EBASE 3 +fp!,
  -	rfs,
  -
   \ relmem is used to release previously allocated memory, as returned by getmem.
  -\ Arguments:
  -\	+0	Return PC
  -\	+1	Block of memory to release, as returned by getmem.
   \ Nothing is returned.
   
  -sub: relmem
  -	1 +fp@,  -/node +,  1 +fp!,
  -	1 +fp@, 2 #, +, @,  -/node and,  1 +fp@, 2 #, +, !,
  -	rfs,
  +:, relmem
  +	memptr @,  -/node +,  memptr !,
  +	memptr @, 2 #, +, @,  -/node and,  memptr @, 2 #, +, !,  ;,
   
   \ First instruction of STS starts here.  coldstart vectors here.
   
   :, cold		$4000 #, %fp !,			( Initialize the STS frame pointer )
   		-8 fp+!,			( Let user know we're running )
  -			$C000 #, 1 +fp!,
  -			40 #, 2 +fp!,
  -			80 #, 3 +fp!,
  -			100 #, 4 +fp!,
  -			$0000 #, 5 +fp!,
  +			$C000 #, bitmapptr !,
  +			40 #, wrdperrow !,
  +			80 #, rowendres !,
  +			100 #, rowperbox !,
  +			$0000 #, bitmapdat !,
   			fillRect
   
  -			0 #, 1 +fp!,		( locate free memory pool )
  -			$3000 #, 2 +fp!,
  +			0 #, fndtagsta !,	( locate free memory pool and initialize it. )
  +			$3000 #, fndtagend !,
   			findTag
  -			4 +fp@, if,		( If not found... )
  -				$C000 #, 1 +fp!,	( indicate error to user and halt )
  -				40 #, 2 +fp!,
  -				0 #, 3 +fp!,
  -				200 #, 4 +fp!,
  -				$FFFF #, 5 +fp!,
  +			rsn @, if,		( If not found... )
  +				$C000 #, bitmapptr !,	( indicate error to user and halt )
  +				40 #, wrdperrow !,
  +				0 #, rowendres !,
  +				200 #, rowperbox !,
  +				$FFFF #, bitmapdat !,
   				fillRect
   				halt,
   			then,
  -			3 +fp@, $C000 #, +, 1 +fp!,
  -			3 +fp@, $C000 #, +, poolbase !,
  -			3 +fp@, -1 #, xor, 1 #, +, $4000 #, +, 2 +fp!,
  +			fndtagsta @, $C000 #, +, mplsta !,
  +			fndtagsta @, -1 #, xor, 1 #, +, $4000 #, +, mplsiz !,
   			fmtmem
   
   \			$C000 #, 1 +fp!,	( Memory pool updated.  Time to mount our filesystem. )
  
positive.code: \			$0000 #, 5 +fp!,
  \			fillRect
  
  			256 #, 1 +fp!,
  			getmem
  			3 +fp@,
  			if,	$F640 #, crash halt,
  			then,
  			2 +fp@, 0=
  			if,	$F642 #, crash halt,
  			then,
  			2 +fp@, -3 +fp!,
  			256 #, 1 +fp!,
  			getmem
  			3 +fp@,
  			if,	$F644 #, crash halt,
  			then,
  			2 +fp@, -3 +fp@, xor, 0=
  			if,	$F646 #, crash halt,
  			then,
  
  			2 +fp@, 1 +fp!, relmem
  			-3 +fp@, 1 +fp!, relmem
  
  			512 #, 1 +fp!,
  			getmem
  			3 +fp@,
  			if,	$F740 #, crash halt,
  			then,
  
  			2 +fp@,  poolbase @, /node +, xor, crash
  		8 fp+!,
  
  		
  
negative.code: \	+3	undefined
  \	+4	Reason code (non-zero)
  
  int, fndtagend
  int, fndtagsta
  
  :, findTag
  	fndtagend @, -1 #, xor, 1 #, +,  fndtagsta @, +, $8000 #, and,
  	if,	fndtagsta @, 0 #, +, @,
  		fndtagsta @, 2 #, +, @, +,
  		fndtagsta @, 4 #, +, @, +,
  		fndtagsta @, 6 #, +, @, +,
  		$FFFF #, xor,
  		if,  fndtagsta @, 2 #, +, fndtagsta !,  again,
  		then,
  
  		fndtagsta @, @,  $C0DE #, xor,
  		if,  fndtagsta @, 2 #, +, fndtagsta !,  again,
  		then,
  
  		fndtagsta @, 2 #, +, @,  fndtagsta @,  xor,
  		if,  fndtagsta @, 2 #, +, fndtagsta !,  again,
  		then,
  
  		fndtagsta @, 4 #, +, @,  $DA7A #, xor,
  		if,  fndtagsta @, 2 #, +, fndtagsta !,  again,
  		then,
  
  		0 #, rsn !,
  		exit,
  	then,
  	ENOTFOUND rsn !, ;,
  
  \ fmtmem formats a memory pool with the required metadata to support allocation requests.
  \ Arguments:
  