Go to the Index

# Inside Spacewar!Part 4: The Outline Compiler

In this part of our software archeological journey through the internals of Spacewar!, the earliest known digital video game, we're going to peek inside one of the most opaque parts of Spacewar!, Dan Edwards' famous outline compiler for drawing the spaceships.

BTW: You can play here the original code of Spacewar! running in an emulation.

There is some history behind this piece of code: Once there would have been an outline interpreter by Steve Russell which would be stepping over the defining outline data held in a separate table per spaceship. But with the introduction of the code for calculating gravity — also by Dan Edwards and all-important to the gameplay — the game was driven beyond flicker-free display performance. Enter the outline compiler, maintaining both the required speed and the configureable outlines:

The ship outlines were represented as a series of direction codes starting from the nose of the ship; when the ship was vertical and tail-down, each code pointed to one of the five possible adjacent dots could be displayed next. To display the ship at an angle, Russell calculated the appropriate sine and cosine and added them to the original direction code constants, in effect rotating the entire grid. With this method, the ship's angle had to be calculated only once in each display frame. The outline codes were kept in a table so that different shapes could be tried out at will, but this meant the table had to be searched every frame to generate the outline. As the game developed, this arrangement proved to be a sticking point which we shall see, was neatly solved by Dan Edwards.
(…)
The addition of gravity pushed Spacewar! over the edge of flicker-free display. To get back under the limit, Dan Edwards devised an elegant fiddle to speed up the outline display routine.
In Russell's original program, the outline tables were examined and interpreted in every display frame, an essentially redundant operation. Edwards replaced this procedure with an outline "compiler," which examined the tables at the start of a game and compiled a short program to generate the outline for each ship. This dramatically reduced calculation time, restoring the steady display and making room for the last of the original bells and whistles. (J. M. Graetz, "The Origin of Spacewar", Creative Computing, August 1981)

So, instead of iterating over the data twice per frame (once for each ship) and having to do all this parsing of the data and branching to various parts of the code based on the encoded commands, the outline data would be parsed once for all at the start of the game. The outline compiler would step over the various data points and would assemble the required code in a single stream of commands, to be injected into the PDP-1's memory just after the end of the data of the collidible objects table. Thus, there are now two sides to the code, which is effectively separating into two distinctive tasks, what would have been done at once by the interpreter before: On the one hand, there's the branching required to follow an outline as encoded in the outline table, which is done at compile time. On the other hand, there is the actual drawing in a 2D context, done by calling the resulting object code. For this, the main program would have to supply the current x and y coordinates telling the compiled code were to draw the outline. And it will have to tell the compiled routine, at wich angle to draw a ship. (There will be probably some trigonometry involved in order to map a given rotation angle to a Cartesian coordinate system.)

We've already seen in Part 3, how the outline compiler would have been initially called at the start of the program. Let's see, what's actually happening, when "`jda oc`" is executed …

## The Code

Credits: Spacewar! was conceived in 1961 by Martin Graetz, Stephen Russell, and Wayne Wiitanen. It was first realized on the PDP-1 in 1962 by Stephen Russell, Peter Samson, Dan Edwards, and Martin Graetz, together with Alan Kotok, Steve Piner, and Robert A Saunders. Spacewar! is in the public domain, but this credit paragraph must accompany all distributed versions of the program.
```	/outline compiler
/ac=where to compile to, call   jda oc
/ot=address of outline table

define
plinst A
lac A
dac i oc
idx oc
terminate

define
comtab A, B
plinst A
jsp ocs
lac B
jmp oce
terminate

ocs,	dap ocz		/puts in swap
dio i oc
idx oc
dio i oc
idx oc
ocz,	jmp .

oc,	0		/outline compiler proper
dap ocx
lac i ocx
dap ocg
plinst (stf 5
dap ocm
idx ocx
ock,	plinst (lac \sx1
plinst (lio \sy1
clf 6
ocj,	setup \occ,6
ocg,	lio .		/outline table
och,	cla
rcl 3s
dio \oci
lio (rcl 9s
dispatch
opr
jmp oc1
oco,	jmp oc2
ocq,	jmp oc3
ocp,	jmp oc4
ocr,	jmp oc5
jmp oc6

plinst (szf 5	/7 code
add (4
dap ocn
plinst ocn
plinst (dac \sx1
plinst (dio \sy1
plinst (jmp sq6
plinst (clf 5
plinst (lac \scm
plinst (cma
plinst (dac \scm
plinst (lac \ssm
plinst (cma
plinst (dac \ssm
plinst (lac \csm
plinst (lio \ssd
plinst (dac \ssd
plinst (dio \csm
plinst (lac \ssc
plinst (lio \csn
plinst (dac \csn
plinst (dio \ssc
plinst ocm
ocx,	jmp .

ocm,	jmp .
ocn,	jmp .

oc1,	plinst (add \ssn
jsp ocs
lac (sub \scn
oce,	dac i oc
idx oc
jsp ocs
plinst (ioh
lac (dpy-4000
ocd,	dac i oc
idx oc
lio \oci
count \occ, och
idx ocg
jmp ocj

oc2,	comtab (add \scm, (add \ssm
oc3,	comtab (add \ssc, (sub \csm
oc4,	comtab (sub \scm, (sub \ssm
oc5,	comtab (add \csn, (sub \ssd
oc6,	szf 6
jmp oc9
stf 6
plinst (dac \ssa
lac (dio \ssi
jmp ocd
oc9,	clf 6
plinst (lac \ssa
lac (lio \ssi
jmp ocd```

And this is the data defining the outlines of the spaceships:

```/ outlines of spaceships

ot1,	111131
111111
111111
111163
311111
146111
111114
700000
. 5/

ot2,	013113
113111
116313
131111
161151
111633
365114
700000
. 5/```

(For the basics of PDP-1 instructions and Macro assembler code, please refer to Part 1. We'll repeat the semantics of the instructions as we're encountering them.)

Where to start with this piece of code? Following best practice, we'll start at the beginning, right where the compiler is called by the main code:

## Compiling the Outlines

As we might remember from Part 3, the outline compiler is called by the following instructions, here for spaceship 1:

```	law nnn		/ start of outline program
dac not
/	...
jda oc		/ compile outline
ot1```

This is loading the address of the location right after the data of the objects table into the accumulator, stores this for later use as the start address of the compiled code in the location labeled `not`, and calls the outline compiler by the instruction "`jda oc`", followed by the address of the outline data for the first spaceship in the next location.

As we already know (from previous parts), instruction `jda` deposits the contents of the accumulator in the location provided in the address part, puts the value of the program counter plus 1 into the accumulator (to be used as the return address) and jumps to the next location after the provided address. By this, we've successfully passed the start address for the code (in `oc`) as well as the address of the data (in the accumulator), and make a jump to `oc+1`.

Note: It might be fair to note here that this technique of passing multiple parameters is already to be found in the multiply and divide routines by BBN (Bolt, Beranek and Newman) and might have been adopted from there.

```oc,	0		/outline compiler proper
dap ocx		// store address of pointer to the data in ocx
lac i ocx	// load first data word
dap ocg		// store it in address part of ocg
plinst (stf 5	// compile "stf 5" (set flag 5)
dap ocm		// put the current object code address in ocm
idx ocx		// index ocx, now the actual return address```

(As usual, comments starting with double slashes are mine and not in the original code.)

With location `oc` serving as the pointer for the generated object code, we enter at the next instruction, where we store the location of the data table in the address part of `ocx`. (This is using the naming convention generally indicating a return address. We'll see soon, why this would be so.) Then, we load the contents of the address to which the value in `ocx` is pointing to, the very first location of the data table, into the accumulator. This first data word is then stored in `ocg`, serving as the store for the current data word.

The macro `plinst` (push last instruction ?) injects the provided constant expression in the current (or currently last) location of the object code as designated by `oc` and increments `oc` to point to the next location. As a side effect, the current value of `oc` is also left in the accumulator. This is now stored in the address part of location `ocm` (which is already containing a `jmp` in the instruction part) for later use. We may note that this is the location of the next instruction after the very first "`stf 5`" (set flag 5) at the start of the compiled code.

Finally, the contents of `ocx` is incremented by 1, now pointing to the actual return address after the pointer to the outline data.

Let's have a closer look at macro `plinst`, which is performing most of the actual assembly:

```define
plinst A
lac A
dac i oc
idx oc
terminate```

This macro is taking a single argument (`A`), a constant expression which is loaded into the accumulator by the first `lac`. This value is then deposited in the location to which `oc` is currently pointing to. Finally, the instruction "`idx oc`" increments the contents of `oc`, leaving the incremented value in the accumulator as a side effect.

The following instructions are finializing the setup steps:

```ock,	plinst (lac \sx1	// compile "lac \sx1" (load x into AC)
plinst (lio \sy1	// compile "lio \sy1" (load y into IO)
clf 6			// clear flag 6
ocj,	setup \occ,6		// initialize \occ with -6```

The first two pseudo instruction insert the macor `plinst` to compile the instructions "`lac \sx1`" and "`lio \sy1`", effecting in the object code to load the x-position and the y-position of the current object (the spaceship) into the accumulator and the IO register respectively. Then "`clf 6`" clears program flag 6 and the macro `setup` (which we've already seen in Part 3) sets the variable `\occ` to the value `-6` to be used as a count-up.

By now, the compiled code is:

```	stf 5
lac \sx1
lio \sy1```

As we may remember from Part 3, the variables `\sx1` and `\sy1` are containing the x and y coordinates of the current spaceship in the format used by the `dpy` instruction (with the most significant 10 bits indicating the position and the lower 8 bits ignored). Thus, in the compiled code, AC and IO are now pointing to the very first display location as stored in `\sx1` and `\sy1`.

```ocg,	lio .		/outline table  // load current data word into IO
och,	cla		// clear AC
rcl 3s		// rotate first three bits (first nibble) of IO into AC
dio \oci	// store rest in \oci
lio (rcl 9s	// load constant "rcl 9s" into IO
dispatch	// like FORTRAN computed GO TO on contents of AC
opr		// case 0: nop, fall through
jmp oc1		// case 1
oco,	jmp oc2		// case 2
ocq,	jmp oc3		// case 3
ocp,	jmp oc4		// case 4
ocr,	jmp oc5		// case 5
jmp oc6		// case 6
...		// case 7```

With this initial setup done, we're heading straight to the actual parsing. At `ocg` the `lio` instruction loads the contents of the current data word (this being the very first location, inserted previously by a `dap` instruction) into the IO register. The next instruction "`rcl 3s`" (rotate combined registers left) rotates the highest three bits (or nibble, or the first octal digit) into the accumulator, with the remainder stored in the variable `\oci` for later use. As we can already see, the commands creating the outlines are encoded in three bits or a single octal digit. Since there are 6 of them in an 18-bit word, we also can now understand, why the counter `occ` would have been initialized for a countup from `-6`. The next pseudo instruction inserts the production of the macro `dispatch`, which is quite the equivalent of a FORTRAN computed GO TO statement (or, as we would call this in assembler, is setting up a jump by a dispatch table):

```	define
dispatch
add (. 3	// add current address + 3 (first after macro) to AC
dap . 1		// deposit in next address
jmp .		// and jump there
term```

The macro effects in an indexed jump to any of the 7 locations following immediately after its insertion.
(In case you would wonder, this macro is defined at the top of the source of part 1, in the section containing the macros specific to Spacewar!. This placement and the fact that it is used only here once, suggests that this might have been a piece of code used more commonly by the original outline interpreter.)

The first instruction of the dispatch table, executed in case that the accumulator would contain `0`, is a simple `opr`, synonymous to `nop` (no operation). This will simply fall through to the next case.

The next `jmp` instructions cover the cases for the acumulator containing any value in the range `1..6`, and with `7`, we would continue with the code following to these jump vectors.

Let's see, what's happening, in case we would take the jump to `oc1` for a nibble of value `1` in our data word:

```oc1,	plinst (add \ssn	// compile "add \ssn"
jsp ocs			// copy IO to the next 2 addresses at oc (swap)
lac (sub \scn		// load "sub \scn" into AC
oce,	dac i oc		// display action: deposit AC at current code location
idx oc			// increment oc
jsp ocs			// copy IO to the next 2 addresses at oc (swap)
plinst (ioh		// compile "ioh" (wait for completion pulse)
lac (dpy-4000		// load "dpy-400" into AC
ocd,	dac i oc		// deposit at current code location
idx oc			// increment oc
lio \oci		// advance to next nibble or word: load \oci in IO
count \occ, och		// increment \occ (up from -6), while negative,
// jump to och (get next nibble and execute switch)
idx ocg			// increment ocg (next data word)
jmp ocj			// start over with the new data word```

After compiling "`add \ssn`" by inserting macro `plinst` (we'll explore the semantics of these variables soon), the jump to the subroutine `ocs` effects in the compiliation of twice the contents of IO:

```ocs,	dap ocz		/puts in swap // deposit return address in ocz
dio i oc	// deposit IO in address in oc
idx oc		// increment oc
dio i oc	// deposit IO in address in oc
idx oc		// increment oc
ocz,	jmp .		// return```

Since the IO register was set up to contain the value of the constant expression "`rcl 9s`", this will insert the equivalent of the macro `swap`, we've seen already in Part 2: Two consecutive instructions to rotate AC and IO as a combined register by 9 bits, resulting in an exchange of the contents of the two registers. As we may remember, this was used to set up AC for the x-coordinate of a `dpy` instruction, then swap the registers, compose the y-coordinate in the accumulator, and swap the registers back, now with the y-coordinate in IO and the x-coordinate in AC.

This is exactly what is compiled here: AC was set up in the compiled code to contain the current x-coordinate as in `\sx1`. This is now swapped and the accumulator is now containing the current y-position. The expression "`sub \scn`" is now compiled and this is followed by another call of `ocs`, inserting another swap.

The pseudo instruction "`plinst (ioh`" compiles a `ioh` instruction, resulting in the CPU to wait for the completion pulse sent by the CRT display. (For details, please refer to Part 2.) Then the constant expression for the actual display command "`dpy-4000`" is loaded into AC. At `ocd` this is put at the current end of the object code stack and the pointer `oc` is incremented once again.

By now, this inserted the following code production in the object code at `oc`, updating both the x and y coordinates, waiting for the display to be ready, and finally issuing a new display command:

```	add \ssn
rcl 9s
rcl 9s
sub \scn
rcl 9s
rcl 9s
ioh
dpy-4000```

With the actual compilation done, we're left with advancing to the next nibble of the outline data (last few lines repeated from above):

```	lio \oci		// advance to next nibble or word: load \oci in IO
count \occ, och		// increment \occ (up from -6), while negative,
// jump to och (get next nibble and execute switch)
idx ocg			// increment ocg (next data word)
jmp ocj			// start over with the new data word```

This loads the rest of the rotated data word as stored previously in `\oci` into IO, just as befor at label `ocg`. The pseudo instruction "`count \occ, och`" performs the count-up on the 6 nibbles of the data word. (We've seen the macro `count` already in Part 3.) If `\occ` would be still negative after the increment, we would jump to label `och`, rotating the next nibble into AC. If the result would be positive, indicating we would have parsed all 6 nibbles already, we fall through to the next instruction, incrementing the address stored in `ocg` to advance to the next data word. This is then parsed by the jump to `ocj`, resetting the counter `\occ`, and starting over with the new data word.

Having investigated a full loop for parsing and compiling an outline code of `1`, let's see whats happening with some other codes:

```oc2,	comtab (add \scm, (add \ssm
oc3,	comtab (add \ssc, (sub \csm
oc4,	comtab (sub \scm, (sub \ssm
oc5,	comtab (add \csn, (sub \ssd```

The jump vectors for the codes `2..5` will take us to the labels with the respective numbers at their end. Each of them inserts the macro `comtab` with two constant expressions as the arguments, each representing an instruction to be compiled. This is, what `comtab` (command tablutor ?) looks like:

```define
comtab A, B
plinst A		// compile A in oc
jsp ocs			// compile swap
lac B			// put B into AC
jmp oce			// display and advance
terminate```

This is compiling the first parameter into the current location of the object code, adds a swap to it (there's still "`rcl 9s`" in IO) and puts the value of the second parameter into the accumulator. Then it jumps to the label `oce`, we've seen before: This will compile the contents of AC, add another swap to the compiled code, as well as the `ioh` and `dpy-4000` instructions, and execute the next iteration over the parse/compile loop.

Thus, macro `comtab` produces a compiled object code quite like the one we've seen before, with the notable difference of the instructions for updating the x and y coordinates by the expressions in `A` and `B` respectively:

```	A		// first parameter (update x)
rcl 9s
rcl 9s
B		// second parameter (update y)
rcl 9s
rcl 9s
ioh
dpy-4000```

Note: An attentive reader might have noticed that this is the same production as the one of the code entered at `oc1`, even using the same instructions at label `oce` and beyond, but with parameters. Why isn't the code at `oc1` just "`comtab (add \ssn, (sub \scn`"? We don't know, but it's quite as if the code at `oc1` would be exemplifying the workings of the macro `comtab` which would be hidden in some indirectness else.

## Movement Semantics

In order to understand the semantics of these code productions inserted by the outline codes `0...5`, we'll have to peek ahead into some code of the main program, we haven't explored yet. By now, we only know that the outline commands will cause the following movements:

```outline advance by x, y:

0: fall through to 1
1: +\ssn -\scn
2: +\scm +\ssm
3: +\ssc -\csm
4: -\scm -\ssm
5: +\csn -\ssd```

Inside the code managing the spaceships, we'll find the following setup of these variables just before the call of the compiled outline code (at `sp5`), with `\sn` being the sine of the rotation angle in `mth` and `\cs` containing the cosine:

```	scale \sn, 9s, \ssn	// store scaled sine in \ssn
scale \cs, 9s, \scn	// store scaled cosine in \scn
lac \ssn
dac \ssm		// \ssm = \ssn
add \scn
dac \ssc		// \ssc = \ssn + \scn
dac \ssd		// \ssd = \ssn + \scn
lac \ssn
sub \scn
dac \csn		// \csn = \ssn - \scn
cma			// complement AC
dac \csm		// \csm = -\csn
lac \scn
dac \scm		// \scm = \scn
cla cli-opr		// clear AC and IO
dpy-4000		// display a dot in center, request completion pulse
sp5,	jmp .			// jump to compiled outline code
sq6,	ioh			// wait for last completion pulse```

The two insertions of the macro `scale` are scaling the current sine and cosine to a value that would produce an advance by a single display location for a value of `1`. (By altering the scaling factor as in `9s`, we could enlarge the outline by multiplying the steps by powers of 2. This is also the trick applied by Barry Silverman, Brian Silverman, and Vadim Gerasimov in their version of the code of Spacewar! 3.1, modified to display the ships at double size for the benefit of modern displays, by changing this value to `8s`.) Since the format of the positional values for the `dpy` instruction automatically allows for a fractional part of 8 binary digits, any values between `0` and `1` will be handled gracefully, with just the discrete integer parts used as the actual display location.

As we can see, rather than just supplying the turning angle (theta) of the ship, the required trigonometry is done in the main program. This is part of Steve Russell's "basic trick" of calculating the sine and cosine only once per frame and reusing them (resulting in something alike turning the entire universe), here by setting up a matrix of derivative values for the use of the compiled outline routines, which will have to deal with these positional offsets only. This is, what this matrix looks like, when the code produced by the outline compiler is called at label `sq5`:

```\ssn = sin (scaled)
\scn = cos (scaled)
\ssm = \ssn
\ssc = \ssn + \scn
\ssd = \ssn + \scn
\csn = \ssn - \scn
\csm = -(\ssn - \scn)
\scm = \scn```

Before we investigating these values, we may note the actual calling sequence of the compiled outline code: Since the compiled code is starting with a `ioh`, we would need to call a `dpy-4000` instruction before (in order to provide the completion pulse by the display) or the code would be waiting for ever. This is provided by the combined `cla` (clear AC) and `cli` (clear IO) as in "`cla cli-opr`" and the following `dpy-4000` display command. As this is resetting AC and IO to point to the origin at the center of the screen, there will be always a spot at the very center of the scope, even, if the "heavy star" would be disabled by activating sense switch 6. Likewise, the code produced by the compiler loop is ending in a `dpy-4000` instruction, so there's a `ioh` to wait for and clear this final completion pulse at label `sq6`.

Back to the semantics of the outline code, we'll see that just some values are actually used to move the outline in the resulting code. This would translate to the following values and respective movements:

```Movements by x, y:

code / theta (deg)          90        45          30        0
0: => 1
1: +sin       -cos         1 -0    0.7 -0.7    0.5 -0.8    0 -1
2: +cos       +sin         0  1    0.7  0.7    0.8  0.5    1  0
3: +(sin+cos) +(sin-cos)   1  1    1.4  0      1.3 -0.3    1 -1
4: -cos       -sin        -0 -1   -0.7 -0.7   -0.8 -0.5   -1  0
5: +(sin-cos) -(sin+cos)   1 -1    0   -1.4   -0.3 -1.3   -1 -1```

Thus, for a rotation angle theta of `0`, the following semantics apply to the outline codes `0..5`:

```0:           fall through to 1
1:   0 -1    down
2:   1  0    right
3:   1 -1    right down
4:  -1  0    left
5:  -1 -1    left down```

So, what's happening at codes `6` and `7`, and why are there 8 variables defined to encode just 5 distinctive values? Let's see:

## Outline Pragmatics

The codes `6` and `7` may be referred to as the pragmatic part of the outline vocabulary. This is, what's happening at `oc6`, executed for code `6`:

```oc6,	szf 6			// flag 6: store or restore?
jmp oc9			// set: restore position at oc9
stf 6			// set flag 6 for visted, store position
plinst (dac \ssa	// compile "dac \ssa" (deposit AC in \ssa)
lac (dio \ssi		// load "dio \ssi"    (deposit IO in \ssi)
jmp ocd			// compile and next nibble

oc9,	clf 6			// clear flag 6
plinst (lac \ssa	// compile "lac \ssa" (load \ssa)
lac (lio \ssi		// load "lio \ssi"    (load \ssi)
jmp ocd			// compile and next nibble```

So, based on flag 6 set or unset, this either compiles a code that will store the current x and y coordinates as in AC and IO in the variables `\ssa` and `\ssi` respectively, or will restore the current location from these. (Label `ocd` is the final part of the parser/compiler loop, depositing the contents of the accumulator in the current object-code address and advancing to the next nibble or word.)

Since flag 6 is initially cleared just before the start of the loop at label `ocj`, code `6` is alternatingly storing and restore the current display location for the outline.

The part covering code `7` is following immediately to the jump table with the vectors for code `1..6`:

```	plinst (szf 5	/7 code  // compile "szf 5"
add (4			// add 4 (to oc)
dap ocn			// deposit in address part of ocn
plinst ocn		// compile "jmp ocn" (oc+4)
plinst (dac \sx1	// compile "dac \sx1" (deposit AC in \sx1)
plinst (dio \sy1	// compile  "dio \sx1" (deposit IO in \sy1)
plinst (jmp sq6		// compile "jmp sq6" (return)

plinst (clf 5		// compile "clf 5" (clear flag 5)
plinst (lac \scm	// compile "lac \scm" (load \scm into AC)
plinst (cma		// compile "cma" (complement AC)
plinst (dac \scm	// compile "dac \scm" (\scm = -\scm)
plinst (lac \ssm	// compile "lac \ssm"
plinst (cma		// compile "cma"
plinst (dac \ssm	// compile "dac \ssm" (\ssm = -\ssm)
plinst (lac \csm	// compile "lac \csm"
plinst (lio \ssd	// compile "lio \ssd"
plinst (dac \ssd	// compile "dac \ssd" (swap \csm and \ssd)
plinst (dio \csm	// compile "dio \csm" (--"--)
plinst (lac \ssc	// compile "lac \ssc"
plinst (lio \csn	// compile "lio \csn"
plinst (dac \csn	// compile "dac \csn" (swap \csn and \ssc)
plinst (dio \ssc	// compile "dio \ssc" (--"--)
plinst ocm		// compile "jmp <start+1>" (start over)
ocx,	jmp .			// return

ocm,	jmp .
ocn,	jmp .```

As we can see by the jump instruction at label `ocx`, a code of `7` is ending the compilition. Also, as we've seen all of the code of the outline compiler by now, a code `7` must be the last command of any outline data, else the compiler will not return. (Since the current value of `oc` is also left by `plinst` in the accumulator, when executing the jump at `ocx`, the location of the next instruction follwing immediately after the object code will be returned thus in the accumulator to the main program.)

On the pragmatic side, this is producing the following object code as the final coda of the assembled stream:

```szf 5		// flag 5 zero?
jmp . + 4	// no, not visited yet, skip next three instructions
dac \sx1	// yes, update \sx1 and \sx2 to current outline position
dio \sy1
jmp sq6		// return (sq6 is a label in the main program)

clf 5		// clear flag 5
lac \scm
cma
dac \scm	// \scm = -\scm
lac \ssm
cma
dac \ssm	// \ssm = -\ssm
lac \csm
lio \ssd
dac \ssd	// swap \ssd and \csm
dio \csm
lac \ssc
lio \csn
dac \csn	// swap \csn and \ssc
dio \ssc
jmp <ocm>	// start+1```

As we may remember, a "`stf 5`" (set flag 5) was the very first instruction compiled at the head of the resulting outline code. Now this flag is checked. If still set, we haven't seen this code production by command `7` yet and jump to the "`clf 5`" instruction 4 locations ahead, clearing this flag. The next instructions are either complementing or swapping all values related to left and right movements, then the code jumps to the very beginning, just after the initial set flag 5 to start over with the same code, but now drawing the left side.

If we would return from this second run, as indicated by a cleared flag 5, the code stores the current position of the outline in `\sx1` and `\sy1`, the x and y coordinates of the spaceship currently handled. Thanks to this, any exhaust trail to be displayed for a thrusting ship will be drawn at the exact tail position, what ever shape would be described by the outline data.

Now, we may provide the complete instruction set of the outline compiler, properly replacing any references to left and right by in and out, referring to either an inward or outward direction relative to the central y-axis:

```0:  synonymous to 1
1:  down
2:  out
3:  out & down
4:  in
5:  in & down
6:  store /restore current position
7:  draw other side / return```

Note: Actually, we might exchange the terms "out" and "in". Applying them as described here, we would start in a clockwise motion — as used in Spacewar!. By interchanging them, we would still achieve a visually similar result, but now by drawing the first half of the outline in a counterclockwise motion. This is much like describing (a cross section of) a lathe object by describing the curve defining its surface: It doesn't matter, which side of the object we would actually describe, as long as we're using directions consistently.

## Constraints

An attentive reader may have already noticed the following constraints applied to any outline data, to be properly contemplated by any ardent hacker of spaceship outlines (remember the extra space of 4 instruction words appended to each of the data tables?):

• The default orientation is standing on the tail, drawn from the tip downwards (there are only downward and/or sideward movements and store/restore).
• Each outline will be drawn symetrically, mirrored by the y axis. (Dots located at the center will be drawn twice.)
• Each outline should end at the very center and at the very bottom (else any exhaust flames would be drawn in an odd position).
• A spaceship's position, as in `\sx1` and `\sy1`, is actually outside the outlines of the ship (just in front of its tip) — therefor there must be some compensation applied (as we'll see this in a future episode).
• Since runtime is always an issue (and the combination of `ioh` and `dpy-4000` instructions is requiring at least 50 microseconds per outline code, cf. Part 2), each of the spaceships should be drawn by an equal count of outline codes in the interest of a stable frame rate.

It's also this very last constraint, which might shed some light on the else superfluous outline code `0` that is still the very first code of the outline data for the second spaceship, the "wedge", as defined in `ot2`: This might have originally served as some kind of elaborated `NOP`, spending the runtime consumed by any of the other outline commands (each of them being of the same length and cycle count), while effecting essentially in a void instruction, just to compensate for any timing differences. (Please mind that this just a guess and not confirmed by any historical sources or references.)

Sticking to our usual procedures, this would be just the place to investigate a (prominent) variations of the main theme of the article as to be found in some versions of Spacewar!. — But not this time!

The outline compiler was that a success, it didn't see any variations or modifications at all, just like the data defining the outline of two spaceships.

With nothing else to show, we're closing here with the disassembly of the productions of the outline compiler for both of the spaceships:

## The Object Code

Disassembly of the spaceship outline code produced by the outline compiler, locations as in Spacewar! 3.1 (labels `c1m` and `c2m` inserted by me, N.L.):

```spaceship 1

ot1,	111131
111111
111111
111163
311111
146111
111114
700000

loc.    instr.     opcode       symbols

3772    760015     stf 5        stf 5
3773    203225     lac 3225     c1m,	lac \sx1
3774    223226     lio 3226     lio \sy1
3775    403223     add 3223     add \ssn
3776    663777     rcl 9s       rcl 9s
3777    663777     rcl 9s       rcl 9s
4000    423224     sub 3224     sub \scn
4001    663777     rcl 9s       rcl 9s
4002    663777     rcl 9s       rcl 9s
4003    730000     ioh          ioh
4004    724007     dpy-4000     dpy-4000
4005    403223     add 3223     add \ssn
4006    663777     rcl 9s       rcl 9s
4007    663777     rcl 9s       rcl 9s
4010    423224     sub 3224     sub \scn
4011    663777     rcl 9s       rcl 9s
4012    663777     rcl 9s       rcl 9s
4013    730000     ioh          ioh
4014    724007     dpy-4000     dpy-4000
4015    403223     add 3223     add \ssn
4016    663777     rcl 9s       rcl 9s
4017    663777     rcl 9s       rcl 9s
4020    423224     sub 3224     sub \scn
4021    663777     rcl 9s       rcl 9s
4022    663777     rcl 9s       rcl 9s
4023    730000     ioh          ioh
4024    724007     dpy-4000     dpy-4000
4025    403223     add 3223     add \ssn
4026    663777     rcl 9s       rcl 9s
4027    663777     rcl 9s       rcl 9s
4030    423224     sub 3224     sub \scn
4031    663777     rcl 9s       rcl 9s
4032    663777     rcl 9s       rcl 9s
4033    730000     ioh          ioh
4034    724007     dpy-4000     dpy-4000
4035    403235     add 3235     add \ssc
4036    663777     rcl 9s       rcl 9s
4037    663777     rcl 9s       rcl 9s
4040    423233     sub 3233     sub \csm
4041    663777     rcl 9s       rcl 9s
4042    663777     rcl 9s       rcl 9s
4043    730000     ioh          ioh
4044    724007     dpy-4000     dpy-4000
4045    403223     add 3223     add \ssn
4046    663777     rcl 9s       rcl 9s
4047    663777     rcl 9s       rcl 9s
4050    423224     sub 3224     sub \scn
4051    663777     rcl 9s       rcl 9s
4052    663777     rcl 9s       rcl 9s
4053    730000     ioh          ioh
4054    724007     dpy-4000     dpy-4000
4055    403223     add 3223     add \ssn
4056    663777     rcl 9s       rcl 9s
4057    663777     rcl 9s       rcl 9s
4060    423224     sub 3224     sub \scn
4061    663777     rcl 9s       rcl 9s
4062    663777     rcl 9s       rcl 9s
4063    730000     ioh          ioh
4064    724007     dpy-4000     dpy-4000
4065    403223     add 3223     add \ssn
4066    663777     rcl 9s       rcl 9s
4067    663777     rcl 9s       rcl 9s
4070    423224     sub 3224     sub \scn
4071    663777     rcl 9s       rcl 9s
4072    663777     rcl 9s       rcl 9s
4073    730000     ioh          ioh
4074    724007     dpy-4000     dpy-4000
4075    403223     add 3223     add \ssn
4076    663777     rcl 9s       rcl 9s
4077    663777     rcl 9s       rcl 9s
4100    423224     sub 3224     sub \scn
4101    663777     rcl 9s       rcl 9s
4102    663777     rcl 9s       rcl 9s
4103    730000     ioh          ioh
4104    724007     dpy-4000     dpy-4000
4105    403223     add 3223     add \ssn
4106    663777     rcl 9s       rcl 9s
4107    663777     rcl 9s       rcl 9s
4110    423224     sub 3224     sub \scn
4111    663777     rcl 9s       rcl 9s
4112    663777     rcl 9s       rcl 9s
4113    730000     ioh          ioh
4114    724007     dpy-4000     dpy-4000
4115    403223     add 3223     add \ssn
4116    663777     rcl 9s       rcl 9s
4117    663777     rcl 9s       rcl 9s
4120    423224     sub 3224     sub \scn
4121    663777     rcl 9s       rcl 9s
4122    663777     rcl 9s       rcl 9s
4123    730000     ioh          ioh
4124    724007     dpy-4000     dpy-4000
4125    403223     add 3223     add \ssn
4126    663777     rcl 9s       rcl 9s
4127    663777     rcl 9s       rcl 9s
4130    423224     sub 3224     sub \scn
4131    663777     rcl 9s       rcl 9s
4132    663777     rcl 9s       rcl 9s
4133    730000     ioh          ioh
4134    724007     dpy-4000     dpy-4000
4135    403223     add 3223     add \ssn
4136    663777     rcl 9s       rcl 9s
4137    663777     rcl 9s       rcl 9s
4140    423224     sub 3224     sub \scn
4141    663777     rcl 9s       rcl 9s
4142    663777     rcl 9s       rcl 9s
4143    730000     ioh          ioh
4144    724007     dpy-4000     dpy-4000
4145    403223     add 3223     add \ssn
4146    663777     rcl 9s       rcl 9s
4147    663777     rcl 9s       rcl 9s
4150    423224     sub 3224     sub \scn
4151    663777     rcl 9s       rcl 9s
4152    663777     rcl 9s       rcl 9s
4153    730000     ioh          ioh
4154    724007     dpy-4000     dpy-4000
4155    403223     add 3223     add \ssn
4156    663777     rcl 9s       rcl 9s
4157    663777     rcl 9s       rcl 9s
4160    423224     sub 3224     sub \scn
4161    663777     rcl 9s       rcl 9s
4162    663777     rcl 9s       rcl 9s
4163    730000     ioh          ioh
4164    724007     dpy-4000     dpy-4000
4165    403223     add 3223     add \ssn
4166    663777     rcl 9s       rcl 9s
4167    663777     rcl 9s       rcl 9s
4170    423224     sub 3224     sub \scn
4171    663777     rcl 9s       rcl 9s
4172    663777     rcl 9s       rcl 9s
4173    730000     ioh          ioh
4174    724007     dpy-4000     dpy-4000
4175    403223     add 3223     add \ssn
4176    663777     rcl 9s       rcl 9s
4177    663777     rcl 9s       rcl 9s
4200    423224     sub 3224     sub \scn
4201    663777     rcl 9s       rcl 9s
4202    663777     rcl 9s       rcl 9s
4203    730000     ioh          ioh
4204    724007     dpy-4000     dpy-4000
4205    403223     add 3223     add \ssn
4206    663777     rcl 9s       rcl 9s
4207    663777     rcl 9s       rcl 9s
4210    423224     sub 3224     sub \scn
4211    663777     rcl 9s       rcl 9s
4212    663777     rcl 9s       rcl 9s
4213    730000     ioh          ioh
4214    724007     dpy-4000     dpy-4000
4215    403223     add 3223     add \ssn
4216    663777     rcl 9s       rcl 9s
4217    663777     rcl 9s       rcl 9s
4220    423224     sub 3224     sub \scn
4221    663777     rcl 9s       rcl 9s
4222    663777     rcl 9s       rcl 9s
4223    730000     ioh          ioh
4224    724007     dpy-4000     dpy-4000
4225    403223     add 3223     add \ssn
4226    663777     rcl 9s       rcl 9s
4227    663777     rcl 9s       rcl 9s
4230    423224     sub 3224     sub \scn
4231    663777     rcl 9s       rcl 9s
4232    663777     rcl 9s       rcl 9s
4233    730000     ioh          ioh
4234    724007     dpy-4000     dpy-4000
4235    403223     add 3223     add \ssn
4236    663777     rcl 9s       rcl 9s
4237    663777     rcl 9s       rcl 9s
4240    423224     sub 3224     sub \scn
4241    663777     rcl 9s       rcl 9s
4242    663777     rcl 9s       rcl 9s
4243    730000     ioh          ioh
4244    724007     dpy-4000     dpy-4000
4245    403223     add 3223     add \ssn
4246    663777     rcl 9s       rcl 9s
4247    663777     rcl 9s       rcl 9s
4250    423224     sub 3224     sub \scn
4251    663777     rcl 9s       rcl 9s
4252    663777     rcl 9s       rcl 9s
4253    730000     ioh          ioh
4254    724007     dpy-4000     dpy-4000
4255    243237     dac 3237     dac \ssa
4256    323240     dio 3240     dio \ssi
4257    403235     add 3235     add \ssc
4260    663777     rcl 9s       rcl 9s
4261    663777     rcl 9s       rcl 9s
4262    423233     sub 3233     sub \csm
4263    663777     rcl 9s       rcl 9s
4264    663777     rcl 9s       rcl 9s
4265    730000     ioh          ioh
4266    724007     dpy-4000     dpy-4000
4267    403235     add 3235     add \ssc
4270    663777     rcl 9s       rcl 9s
4271    663777     rcl 9s       rcl 9s
4272    423233     sub 3233     sub \csm
4273    663777     rcl 9s       rcl 9s
4274    663777     rcl 9s       rcl 9s
4275    730000     ioh          ioh
4276    724007     dpy-4000     dpy-4000
4277    403223     add 3223     add \ssn
4300    663777     rcl 9s       rcl 9s
4301    663777     rcl 9s       rcl 9s
4302    423224     sub 3224     sub \scn
4303    663777     rcl 9s       rcl 9s
4304    663777     rcl 9s       rcl 9s
4305    730000     ioh          ioh
4306    724007     dpy-4000     dpy-4000
4307    403223     add 3223     add \ssn
4310    663777     rcl 9s       rcl 9s
4311    663777     rcl 9s       rcl 9s
4312    423224     sub 3224     sub \scn
4313    663777     rcl 9s       rcl 9s
4314    663777     rcl 9s       rcl 9s
4315    730000     ioh          ioh
4316    724007     dpy-4000     dpy-4000
4317    403223     add 3223     add \ssn
4320    663777     rcl 9s       rcl 9s
4321    663777     rcl 9s       rcl 9s
4322    423224     sub 3224     sub \scn
4323    663777     rcl 9s       rcl 9s
4324    663777     rcl 9s       rcl 9s
4325    730000     ioh          ioh
4326    724007     dpy-4000     dpy-4000
4327    403223     add 3223     add \ssn
4330    663777     rcl 9s       rcl 9s
4331    663777     rcl 9s       rcl 9s
4332    423224     sub 3224     sub \scn
4333    663777     rcl 9s       rcl 9s
4334    663777     rcl 9s       rcl 9s
4335    730000     ioh          ioh
4336    724007     dpy-4000     dpy-4000
4337    403223     add 3223     add \ssn
4340    663777     rcl 9s       rcl 9s
4341    663777     rcl 9s       rcl 9s
4342    423224     sub 3224     sub \scn
4343    663777     rcl 9s       rcl 9s
4344    663777     rcl 9s       rcl 9s
4345    730000     ioh          ioh
4346    724007     dpy-4000     dpy-4000
4347    403223     add 3223     add \ssn
4350    663777     rcl 9s       rcl 9s
4351    663777     rcl 9s       rcl 9s
4352    423224     sub 3224     sub \scn
4353    663777     rcl 9s       rcl 9s
4354    663777     rcl 9s       rcl 9s
4355    730000     ioh          ioh
4356    724007     dpy-4000     dpy-4000
4357    423231     sub 3231     sub \scm
4360    663777     rcl 9s       rcl 9s
4361    663777     rcl 9s       rcl 9s
4362    423232     sub 3232     sub \ssm
4363    663777     rcl 9s       rcl 9s
4364    663777     rcl 9s       rcl 9s
4365    730000     ioh          ioh
4366    724007     dpy-4000     dpy-4000
4367    203237     lac 3237     lac \ssa
4370    223240     lio 3240     lio \ssi
4371    403223     add 3223     add \ssn
4372    663777     rcl 9s       rcl 9s
4373    663777     rcl 9s       rcl 9s
4374    423224     sub 3224     sub \scn
4375    663777     rcl 9s       rcl 9s
4376    663777     rcl 9s       rcl 9s
4377    730000     ioh          ioh
4400    724007     dpy-4000     dpy-4000
4401    403223     add 3223     add \ssn
4402    663777     rcl 9s       rcl 9s
4403    663777     rcl 9s       rcl 9s
4404    423224     sub 3224     sub \scn
4405    663777     rcl 9s       rcl 9s
4406    663777     rcl 9s       rcl 9s
4407    730000     ioh          ioh
4410    724007     dpy-4000     dpy-4000
4411    403223     add 3223     add \ssn
4412    663777     rcl 9s       rcl 9s
4413    663777     rcl 9s       rcl 9s
4414    423224     sub 3224     sub \scn
4415    663777     rcl 9s       rcl 9s
4416    663777     rcl 9s       rcl 9s
4417    730000     ioh          ioh
4420    724007     dpy-4000     dpy-4000
4421    403223     add 3223     add \ssn
4422    663777     rcl 9s       rcl 9s
4423    663777     rcl 9s       rcl 9s
4424    423224     sub 3224     sub \scn
4425    663777     rcl 9s       rcl 9s
4426    663777     rcl 9s       rcl 9s
4427    730000     ioh          ioh
4430    724007     dpy-4000     dpy-4000
4431    403223     add 3223     add \ssn
4432    663777     rcl 9s       rcl 9s
4433    663777     rcl 9s       rcl 9s
4434    423224     sub 3224     sub \scn
4435    663777     rcl 9s       rcl 9s
4436    663777     rcl 9s       rcl 9s
4437    730000     ioh          ioh
4440    724007     dpy-4000     dpy-4000
4441    403223     add 3223     add \ssn
4442    663777     rcl 9s       rcl 9s
4443    663777     rcl 9s       rcl 9s
4444    423224     sub 3224     sub \scn
4445    663777     rcl 9s       rcl 9s
4446    663777     rcl 9s       rcl 9s
4447    730000     ioh          ioh
4450    724007     dpy-4000     dpy-4000
4451    403223     add 3223     add \ssn
4452    663777     rcl 9s       rcl 9s
4453    663777     rcl 9s       rcl 9s
4454    423224     sub 3224     sub \scn
4455    663777     rcl 9s       rcl 9s
4456    663777     rcl 9s       rcl 9s
4457    730000     ioh          ioh
4460    724007     dpy-4000     dpy-4000
4461    403223     add 3223     add \ssn
4462    663777     rcl 9s       rcl 9s
4463    663777     rcl 9s       rcl 9s
4464    423224     sub 3224     sub \scn
4465    663777     rcl 9s       rcl 9s
4466    663777     rcl 9s       rcl 9s
4467    730000     ioh          ioh
4470    724007     dpy-4000     dpy-4000
4471    423231     sub 3231     sub \scm
4472    663777     rcl 9s       rcl 9s
4473    663777     rcl 9s       rcl 9s
4474    423232     sub 3232     sub \ssm
4475    663777     rcl 9s       rcl 9s
4476    663777     rcl 9s       rcl 9s
4477    730000     ioh          ioh
4500    724007     dpy-4000     dpy-4000
4501    640005     szf 5        szf 5
4502    604506     jmp 4506     jmp . 4
4503    243225     dac 3225     dac \sx1
4504    323226     dio 3226     dio \sy1
4505    602531     jmp 2531     jmp sq6
4506    760005     clf 5        clf 5
4507    203231     lac 3231     lac \scm
4510    761000     cma          cma
4511    243231     dac 3231     dac \scm
4512    203232     lac 3232     lac \ssm
4513    761000     cma          cma
4514    243232     dac 3232     dac \ssm
4515    203233     lac 3233     lac \csm
4516    223234     lio 3234     lio \ssd
4517    243234     dac 3234     dac \ssd
4520    323233     dio 3233     dio \csm
4521    203235     lac 3235     lac \ssc
4522    223236     lio 3236     lio \csn
4523    243236     dac 3236     dac \csn
4524    323235     dio 3235     dio \ssc
4525    603773     jmp 3773     jmp c1m

spaceship 2

ot2,	013113
113111
116313
131111
161151
111633
365114
700000

loc.    instr.     opcode       symbols

4526    760015     stf 5        stf 5
4527    203225     lac 3225     c2m,  lac \sx1
4530    223226     lio 3226     lio \sy1
4531    403223     add 3223     add \ssn
4532    663777     rcl 9s       rcl 9s
4533    663777     rcl 9s       rcl 9s
4534    423224     sub 3224     sub \scn
4535    663777     rcl 9s       rcl 9s
4536    663777     rcl 9s       rcl 9s
4537    730000     ioh          ioh
4540    724007     dpy-4000     dpy-4000
4541    403223     add 3223     add \ssn
4542    663777     rcl 9s       rcl 9s
4543    663777     rcl 9s       rcl 9s
4544    423224     sub 3224     sub \scn
4545    663777     rcl 9s       rcl 9s
4546    663777     rcl 9s       rcl 9s
4547    730000     ioh          ioh
4550    724007     dpy-4000     dpy-4000
4551    403235     add 3235     add \ssc
4552    663777     rcl 9s       rcl 9s
4553    663777     rcl 9s       rcl 9s
4554    423233     sub 3233     sub \csm
4555    663777     rcl 9s       rcl 9s
4556    663777     rcl 9s       rcl 9s
4557    730000     ioh          ioh
4560    724007     dpy-4000     dpy-4000
4561    403223     add 3223     add \ssn
4562    663777     rcl 9s       rcl 9s
4563    663777     rcl 9s       rcl 9s
4564    423224     sub 3224     sub \scn
4565    663777     rcl 9s       rcl 9s
4566    663777     rcl 9s       rcl 9s
4567    730000     ioh          ioh
4570    724007     dpy-4000     dpy-4000
4571    403223     add 3223     add \ssn
4572    663777     rcl 9s       rcl 9s
4573    663777     rcl 9s       rcl 9s
4574    423224     sub 3224     sub \scn
4575    663777     rcl 9s       rcl 9s
4576    663777     rcl 9s       rcl 9s
4577    730000     ioh          ioh
4600    724007     dpy-4000     dpy-4000
4601    403235     add 3235     add \ssc
4602    663777     rcl 9s       rcl 9s
4603    663777     rcl 9s       rcl 9s
4604    423233     sub 3233     sub \csm
4605    663777     rcl 9s       rcl 9s
4606    663777     rcl 9s       rcl 9s
4607    730000     ioh          ioh
4610    724007     dpy-4000     dpy-4000
4611    403223     add 3223     add \ssn
4612    663777     rcl 9s       rcl 9s
4613    663777     rcl 9s       rcl 9s
4614    423224     sub 3224     sub \scn
4615    663777     rcl 9s       rcl 9s
4616    663777     rcl 9s       rcl 9s
4617    730000     ioh          ioh
4620    724007     dpy-4000     dpy-4000
4621    403223     add 3223     add \ssn
4622    663777     rcl 9s       rcl 9s
4623    663777     rcl 9s       rcl 9s
4624    423224     sub 3224     sub \scn
4625    663777     rcl 9s       rcl 9s
4626    663777     rcl 9s       rcl 9s
4627    730000     ioh          ioh
4630    724007     dpy-4000     dpy-4000
4631    403235     add 3235     add \ssc
4632    663777     rcl 9s       rcl 9s
4633    663777     rcl 9s       rcl 9s
4634    423233     sub 3233     sub \csm
4635    663777     rcl 9s       rcl 9s
4636    663777     rcl 9s       rcl 9s
4637    730000     ioh          ioh
4640    724007     dpy-4000     dpy-4000
4641    403223     add 3223     add \ssn
4642    663777     rcl 9s       rcl 9s
4643    663777     rcl 9s       rcl 9s
4644    423224     sub 3224     sub \scn
4645    663777     rcl 9s       rcl 9s
4646    663777     rcl 9s       rcl 9s
4647    730000     ioh          ioh
4650    724007     dpy-4000     dpy-4000
4651    403223     add 3223     add \ssn
4652    663777     rcl 9s       rcl 9s
4653    663777     rcl 9s       rcl 9s
4654    423224     sub 3224     sub \scn
4655    663777     rcl 9s       rcl 9s
4656    663777     rcl 9s       rcl 9s
4657    730000     ioh          ioh
4660    724007     dpy-4000     dpy-4000
4661    403223     add 3223     add \ssn
4662    663777     rcl 9s       rcl 9s
4663    663777     rcl 9s       rcl 9s
4664    423224     sub 3224     sub \scn
4665    663777     rcl 9s       rcl 9s
4666    663777     rcl 9s       rcl 9s
4667    730000     ioh          ioh
4670    724007     dpy-4000     dpy-4000
4671    403223     add 3223     add \ssn
4672    663777     rcl 9s       rcl 9s
4673    663777     rcl 9s       rcl 9s
4674    423224     sub 3224     sub \scn
4675    663777     rcl 9s       rcl 9s
4676    663777     rcl 9s       rcl 9s
4677    730000     ioh          ioh
4700    724007     dpy-4000     dpy-4000
4701    403223     add 3223     add \ssn
4702    663777     rcl 9s       rcl 9s
4703    663777     rcl 9s       rcl 9s
4704    423224     sub 3224     sub \scn
4705    663777     rcl 9s       rcl 9s
4706    663777     rcl 9s       rcl 9s
4707    730000     ioh          ioh
4710    724007     dpy-4000     dpy-4000
4711    243237     dac 3237     dac \ssa
4712    323240     dio 3240     dio \ssi
4713    403235     add 3235     add \ssc
4714    663777     rcl 9s       rcl 9s
4715    663777     rcl 9s       rcl 9s
4716    423233     sub 3233     sub \csm
4717    663777     rcl 9s       rcl 9s
4720    663777     rcl 9s       rcl 9s
4721    730000     ioh          ioh
4722    724007     dpy-4000     dpy-4000
4723    403223     add 3223     add \ssn
4724    663777     rcl 9s       rcl 9s
4725    663777     rcl 9s       rcl 9s
4726    423224     sub 3224     sub \scn
4727    663777     rcl 9s       rcl 9s
4730    663777     rcl 9s       rcl 9s
4731    730000     ioh          ioh
4732    724007     dpy-4000     dpy-4000
4733    403235     add 3235     add \ssc
4734    663777     rcl 9s       rcl 9s
4735    663777     rcl 9s       rcl 9s
4736    423233     sub 3233     sub \csm
4737    663777     rcl 9s       rcl 9s
4740    663777     rcl 9s       rcl 9s
4741    730000     ioh          ioh
4742    724007     dpy-4000     dpy-4000
4743    403223     add 3223     add \ssn
4744    663777     rcl 9s       rcl 9s
4745    663777     rcl 9s       rcl 9s
4746    423224     sub 3224     sub \scn
4747    663777     rcl 9s       rcl 9s
4750    663777     rcl 9s       rcl 9s
4751    730000     ioh          ioh
4752    724007     dpy-4000     dpy-4000
4753    403235     add 3235     add \ssc
4754    663777     rcl 9s       rcl 9s
4755    663777     rcl 9s       rcl 9s
4756    423233     sub 3233     sub \csm
4757    663777     rcl 9s       rcl 9s
4760    663777     rcl 9s       rcl 9s
4761    730000     ioh          ioh
4762    724007     dpy-4000     dpy-4000
4763    403223     add 3223     add \ssn
4764    663777     rcl 9s       rcl 9s
4765    663777     rcl 9s       rcl 9s
4766    423224     sub 3224     sub \scn
4767    663777     rcl 9s       rcl 9s
4770    663777     rcl 9s       rcl 9s
4771    730000     ioh          ioh
4772    724007     dpy-4000     dpy-4000
4773    403223     add 3223     add \ssn
4774    663777     rcl 9s       rcl 9s
4775    663777     rcl 9s       rcl 9s
4776    423224     sub 3224     sub \scn
4777    663777     rcl 9s       rcl 9s
5000    663777     rcl 9s       rcl 9s
5001    730000     ioh          ioh
5002    724007     dpy-4000     dpy-4000
5003    403223     add 3223     add \ssn
5004    663777     rcl 9s       rcl 9s
5005    663777     rcl 9s       rcl 9s
5006    423224     sub 3224     sub \scn
5007    663777     rcl 9s       rcl 9s
5010    663777     rcl 9s       rcl 9s
5011    730000     ioh          ioh
5012    724007     dpy-4000     dpy-4000
5013    403223     add 3223     add \ssn
5014    663777     rcl 9s       rcl 9s
5015    663777     rcl 9s       rcl 9s
5016    423224     sub 3224     sub \scn
5017    663777     rcl 9s       rcl 9s
5020    663777     rcl 9s       rcl 9s
5021    730000     ioh          ioh
5022    724007     dpy-4000     dpy-4000
5023    403223     add 3223     add \ssn
5024    663777     rcl 9s       rcl 9s
5025    663777     rcl 9s       rcl 9s
5026    423224     sub 3224     sub \scn
5027    663777     rcl 9s       rcl 9s
5030    663777     rcl 9s       rcl 9s
5031    730000     ioh          ioh
5032    724007     dpy-4000     dpy-4000
5033    203237     lac 3237     lac \ssa
5034    223240     lio 3240     lio \ssi
5035    403223     add 3223     add \ssn
5036    663777     rcl 9s       rcl 9s
5037    663777     rcl 9s       rcl 9s
5040    423224     sub 3224     sub \scn
5041    663777     rcl 9s       rcl 9s
5042    663777     rcl 9s       rcl 9s
5043    730000     ioh          ioh
5044    724007     dpy-4000     dpy-4000
5045    403223     add 3223     add \ssn
5046    663777     rcl 9s       rcl 9s
5047    663777     rcl 9s       rcl 9s
5050    423224     sub 3224     sub \scn
5051    663777     rcl 9s       rcl 9s
5052    663777     rcl 9s       rcl 9s
5053    730000     ioh          ioh
5054    724007     dpy-4000     dpy-4000
5055    403236     add 3236     add \csn
5056    663777     rcl 9s       rcl 9s
5057    663777     rcl 9s       rcl 9s
5060    423234     sub 3234     sub \ssd
5061    663777     rcl 9s       rcl 9s
5062    663777     rcl 9s       rcl 9s
5063    730000     ioh          ioh
5064    724007     dpy-4000     dpy-4000
5065    403223     add 3223     add \ssn
5066    663777     rcl 9s       rcl 9s
5067    663777     rcl 9s       rcl 9s
5070    423224     sub 3224     sub \scn
5071    663777     rcl 9s       rcl 9s
5072    663777     rcl 9s       rcl 9s
5073    730000     ioh          ioh
5074    724007     dpy-4000     dpy-4000
5075    403223     add 3223     add \ssn
5076    663777     rcl 9s       rcl 9s
5077    663777     rcl 9s       rcl 9s
5100    423224     sub 3224     sub \scn
5101    663777     rcl 9s       rcl 9s
5102    663777     rcl 9s       rcl 9s
5103    730000     ioh          ioh
5104    724007     dpy-4000     dpy-4000
5105    403223     add 3223     add \ssn
5106    663777     rcl 9s       rcl 9s
5107    663777     rcl 9s       rcl 9s
5110    423224     sub 3224     sub \scn
5111    663777     rcl 9s       rcl 9s
5112    663777     rcl 9s       rcl 9s
5113    730000     ioh          ioh
5114    724007     dpy-4000     dpy-4000
5115    403223     add 3223     add \ssn
5116    663777     rcl 9s       rcl 9s
5117    663777     rcl 9s       rcl 9s
5120    423224     sub 3224     sub \scn
5121    663777     rcl 9s       rcl 9s
5122    663777     rcl 9s       rcl 9s
5123    730000     ioh          ioh
5124    724007     dpy-4000     dpy-4000
5125    243237     dac 3237     dac \ssa
5126    323240     dio 3240     dio \ssi
5127    403235     add 3235     add \ssc
5130    663777     rcl 9s       rcl 9s
5131    663777     rcl 9s       rcl 9s
5132    423233     sub 3233     sub \csm
5133    663777     rcl 9s       rcl 9s
5134    663777     rcl 9s       rcl 9s
5135    730000     ioh          ioh
5136    724007     dpy-4000     dpy-4000
5137    403235     add 3235     add \ssc
5140    663777     rcl 9s       rcl 9s
5141    663777     rcl 9s       rcl 9s
5142    423233     sub 3233     sub \csm
5143    663777     rcl 9s       rcl 9s
5144    663777     rcl 9s       rcl 9s
5145    730000     ioh          ioh
5146    724007     dpy-4000     dpy-4000
5147    403235     add 3235     add \ssc
5150    663777     rcl 9s       rcl 9s
5151    663777     rcl 9s       rcl 9s
5152    423233     sub 3233     sub \csm
5153    663777     rcl 9s       rcl 9s
5154    663777     rcl 9s       rcl 9s
5155    730000     ioh          ioh
5156    724007     dpy-4000     dpy-4000
5157    203237     lac 3237     lac \ssa
5160    223240     lio 3240     lio \ssi
5161    403236     add 3236     add \csn
5162    663777     rcl 9s       rcl 9s
5163    663777     rcl 9s       rcl 9s
5164    423234     sub 3234     sub \ssd
5165    663777     rcl 9s       rcl 9s
5166    663777     rcl 9s       rcl 9s
5167    730000     ioh          ioh
5170    724007     dpy-4000     dpy-4000
5171    403223     add 3223     add \ssn
5172    663777     rcl 9s       rcl 9s
5173    663777     rcl 9s       rcl 9s
5174    423224     sub 3224     sub \scn
5175    663777     rcl 9s       rcl 9s
5176    663777     rcl 9s       rcl 9s
5177    730000     ioh          ioh
5200    724007     dpy-4000     dpy-4000
5201    403223     add 3223     add \ssn
5202    663777     rcl 9s       rcl 9s
5203    663777     rcl 9s       rcl 9s
5204    423224     sub 3224     sub \scn
5205    663777     rcl 9s       rcl 9s
5206    663777     rcl 9s       rcl 9s
5207    730000     ioh          ioh
5210    724007     dpy-4000     dpy-4000
5211    423231     sub 3231     sub \scm
5212    663777     rcl 9s       rcl 9s
5213    663777     rcl 9s       rcl 9s
5214    423232     sub 3232     sub \ssm
5215    663777     rcl 9s       rcl 9s
5216    663777     rcl 9s       rcl 9s
5217    730000     ioh          ioh
5220    724007     dpy-4000     dpy-4000
5221    640005     szf 5        szf 5
5222    605226     jmp 5226     jmp . 4
5223    243225     dac 3225     dac \sx1
5224    323226     dio 3226     dio \sy1
5225    602531     jmp 2531     jmp sq6
5226    760005     clf 5        clf 5
5227    203231     lac 3231     lac \scm
5230    761000     cma          cma
5231    243231     dac 3231     dac \scm
5232    203232     lac 3232     lac \ssm
5233    761000     cma          cma
5234    243232     dac 3232     dac \ssm
5235    203233     lac 3233     lac \csm
5236    223234     lio 3234     lio \ssd
5237    243234     dac 3234     dac \ssd
5240    323233     dio 3233     dio \csm
5241    203235     lac 3235     lac \ssc
5242    223236     lio 3236     lio \csn
5243    243236     dac 3236     dac \csn
5244    323235     dio 3235     dio \ssc
5245    604527     jmp 4527     jmp c2m```

The actual advance over the outline data for each of the spaceships can also be investigated in the illustration at the top of this page.

In case you would have cleared your internal program flag 5 and would be skipping this full loop, there's no more left, but to resort to a final "Stay tuned …"

Vienna, July 2014
www.masswerk.at

In case you would have found any errors or inconsistencies, or would have additional information,
please contact me.

*****

Previous:   Part 3: Objects!
Next:   Part 5: Maneuvering in Space

Back to the index.