Commits

Anonymous committed 26cccd9

Initial import of Wierd distribution version 1.0 revision 2004.0302.

Comments (0)

Files changed (28)

+There are two versions of this program:
+asciiadd.w: reads two characters, adds their ASCII values, and prints them out
+add.w:      like above, but treats 0 as origin, so 1+2 is 3 rather than c
+
+Note that add.w uses the 0 in the top-left corner (which is operationally
+equivalent to the star used elsewhere) for the origin.  This character can be
+changed to an arbitrary one, but 0 has been chosen because it gives the most
+intuitive effect.
+
+See cat.doc for general Wierd notes.
+There are several versions of this program:
+cat1.w: reads one character and write it out, no check for EOF
+cat2.w: pumps input to output, no check for EOF (makes use of the fact that
+        "conditionals" without any stack just continue going, although it
+        would be more logical to terminate the program with an error message)
+cat3.w: reads one character, and if it isn't EOF, dump it out again
+cat4.w: pumps input to output until EOF is reached
+
+Versions 3 and 4 implicitly assume that EOF is -1.  Due to how hard it is to
+change a Wierd program once it has been wired, I, with this very sentence,
+define that Wierd programs will see EOF as -1, even on computers that normally
+use a different method.
+
+Versions 3 and 4 make use of the getput operator, which selects which
+operatation to perform opposite from the specifications.  Since neither I nor
+anybody else (like the writer of hello.w) wishes to change our programs, I
+recommend leaving the interpreter alone and changing the specifications.  Also,
+the angles work the opposite way (the first example in the specifications is
+treated by the interpreter as 315 degrees).  Again, I recommend changing the
+specifications.
+
+The only true use of conditionals is in the EOF test candle (or if you prefer,
+dynamite) of versions 3 and 4, although fake ones appear in versions 2 and 4
+with the top-of-stack known to be zero just to turn the execution around.
+
+It is also interesting to note that the loop to continue reading after the
+first character seems like a big change but takes barely any space (although it
+does cheat by temporarily creating a new thread which soon dies out), while
+testing for EOF seems like a small change (after all, only one out of 256 input
+characters will be affected) but takes a very long wire, primarily because the
+input character is needed twice - once to test for EOF, once to print it out -
+and since there is no stack-duplication operator (not that there is any room
+for it, though gap-sparking could be made to have a side effect) and so I must
+simulate it by putting the character in (1,1) (those coordinates have been
+chosen because they are the easiest to push on the stack), then getting it
+twice.
+
+In cat4.w, the doomed thread (the one which appears when, quite literally,
+looping, and soon vanishes again) might stumble across this character, but
+Wierd has been designed in such a way that this can, at the worst, kill the
+thread off one cycle earlier.  This proves that it is more robust than normal
+languages.  In fact, the ONLY error condition possible in Wierd is if the
+lop-left character is a space (although, as stated above, errors SHOULD also
+appear for insufficient stack), and therefore Wierd is useful to teach
+beginning programmers without getting them frustated about pages full of error
+messages.  Now if you're talking about bugs that aren't caught by the language
+but just have the wrong effect, THOSE are easy.
+
+But although cat4.w is large, it's not a bad as hello.w.  One starts
+understanding why many programs use external data files.  They not only
+increases modifiability (for example, the program does not have to be changed
+if you choose to use a different languange for the output), but also
+significantly decrease program size.
+
+This gap jumping is annoying.  I never yet ran into any need for it (if there
+is nothing around that the program can go to instead, why not just fill the gap
+with stars?), but sometimes the interpreter tries to gap jump when I want it to
+kill the thread (which forces me to make the program LARGER to add space so no
+gap jump occurs, which is the opposite of what it was meant to do), and worse,
+I cannot see how it chooses when and where to jump.  I recommend that the whole
+misfeature be removed.  By the way, according the the manual, "programs beyond
+a certain complexity might simply be impossible to write, and would at least be
+extremely impractical".  If they are impossible, gap jumping will not help (see
+above question).  If practicality is an issue, I should be programming C, not
+Wierd.
+
+A more severe problem is that check-for-zero is the only available conditional.
+This means that if a program wants to check, for exameple, if the top of the
+stack is less than zero, then all 32768 options must be scanned.  Changing this
+would imply having to change existing programs, but the problem is severe
+enough that this is a necessary evil.  The earlier, the better (before even
+more programs use the outdated version).
+
+Although I do not do so myself, it is possible to include in-program comments
+by including text in the program, either as the wire (with underscores
+replacing spaces) or at a nonreachable distance from the program.
+
+Finally, Wierd programs (or rather wires) are a good example of what sould NOT
+be made with a text editor or anything remotely similar to it.  In fact, it
+requires a special "wire editor" which can, as one of its basic operations,
+stretch wires, taking any knotted wires along, and as another, cutting off
+wires for later use and then place them again in a possibly rotated form.  It
+is also useful if it would draw the angles next to the turns.  Sometime in the
+future, when I have a lot of free time and feel excessively insane, I might try
+it.  Don't hold your breath, though.

doc/count.doc.txt

+This program prints sequential ASCII characters, starting with the character in
+(1,1) and ending with the character in (2,2).  Currently, it starts with 0 and
+ends with 9, so it counts through all digits.  A not-so-well-formatted table of
+all printable ASCII characters may be obtained by starting with ! and ending
+with ~.  The former ascii.w (not by me) also tries to print non-printable
+characters, and doesn't automatically stop (beep beep beep beep beep beep beep
+beep beep beep beep beep beep ad nauseum), so my version is fully superior.
+Space may not be used as endpoint (because the endpoints must be parsed as code
+once), but it may appear as intermediate value.
+
+The basic operation is:
+0. Get the current character and place it on the stack.
+1. Write the top-of-stack (the current character) to the terminal.
+2. Get the current character, which was lost from the stack in step 1, again.
+3. Get the termination character and place it on the stack.
+4. Subtract the two values on the stack.
+5. If the result of step 4 was zero (the last character has just been printed),
+   quit the program.  Otherwise, continue to step 6.
+6. The stack is, once again, empty, so push the current character.
+7. Increment the top of stack by dancing "left, left, right, left, right,
+   right", where all turns are 45 degrees.
+8. Put the top of stack in the current character position.
+9. With the stack empty again, go back to step 0 and repeat the whole process.
+
+The wire has many crossings, although all but one are harmless "bridges" which
+do not change direction and just shrink the wire a bit by avoiding padding.
+
+To do: write a newline when done (this is not as easy in Wierd as it sounds,
+because a newline cannot be entered as starting element for a cell), ask the
+user to enter the start and end characters (inputting and remembering is not
+that hard, but the nature of Wierd is such that adding anything at the
+beginning requires a lot of work to get the rest right, see notes in cat.doc
+about a Wierd editor).
+
+See cat.doc for general language notes.  In contrast to what is said there,
+this wire does have comments.  Not many, but the important actions are probably
+somewhere near where the comments say they are.
+This is not a full program (although it can be run as such), but rather a
+reusable subroutine.  Therefore, input is taken directly from memory, and output
+is stored back in memory and on the stack.  There is no user interaction.
+
+Input:  Numerator in (1,1)
+        Denominator is hard-coded 2
+Output: Quotient in (1,1)
+        Remainder pushed on the stack
+        Nothing else cluttered
+
+The algorithm takes O(numerator) time.  There might exist a faster algorithm but
+I don't know it.
+Just to illustrate exactly how sick I am, this took about three hours,
+most of which was fidgeting with the editor to make the geometry work.
+
+OK, I cheated a bit by:
+	-- putting the text in the program
+	-- using the fact that functions with an empty stack are
+		essentially nops
+And I didn't use anything nifty--no multithreading, genuine conditionals,
+or anything of the like.  Just brute force.  I did, however, when I was
+running out of space, "put" the coordinates in memory so I could just
+"get" them later.
+
+Anyway, I found at least one not-quite-as-advertised "feature" in the
+interpreter.  The main one is that a zero on top of the stack does a put
+of put and get, instead of the expected get, and a non-zero does get
+instead of put.  Since I was doing more getting than putting in the
+program, I was actually kind of happy, but that means the spec and my
+comments are wrong (unless you *really* want to declare the least-trivial
+piece of Wierd code written to date *and* the only currently implemented
+interpreter non-standard...).  The others are really obscure things that I
+can't figure out how to fix (the gap-jumping doesn't seem to quite work as
+I understand it).
+
+Well, I could probably strip out another couple of bytes here and there,
+but I just don't have the stomach for it today...
+
+Oh, Ben:  If you're going to try a 99-Bottles program, I'd suggest
+expanding the playing field, since this program clocked in at just under
+128x128...
+
+Now I'm going to bang my head against a softer object for a while so I
+don't notice the pain...
+
+					--John
+
+P.S.  Anybody besides me see the portrait of George Washington in the
+program?  No?  I must be hallucinating, then...Oh, well...
+loop1.w is an infinite loop, which I have tried to write with minimal size (with
+the restraints that any garbage put on the stack must be taken off again, but
+that no popping intructions may be performed when there is still data on the
+stack).  It seems at first that the first row and column can be ommited, but
+this doesn't work, and I suspect broken gap jumping to be the cause.
+
+loop2.w is also an infinite loop, but with the extra restraint that no threads
+may be started.  Notice how the horizontal line at the bottom can be entered by
+two parallel paths.  The leftmost path is used the first time, afterwards the
+rightmost path is used.  Both have the same angle, therefore the same effect.
+
+For more information on this broken gap jumping, and the language in general,
+see cat.doc.

doc/output.doc.txt

+This program takes the number at (1,1) (input as the ASCII code of a character)
+and prints it in binary (I would do decimal but that would require a divide by
+ten subroutine), using the halving subroutine in half.w.  Since it takes the
+number direct;y from memory, this proram is not quite suitable for the end-user,
+but rather it can be used as a subroutine in a yet larger program.
+
+The algorithm takes O(n) time, most of which is spent in the halving subroutine.

doc/quine.doc.txt

+Note: coordinates (x,y) here mean that y is the higher-on-stack (the row) and x
+is below it (the column).  The "stack" position is, of course, for purposes of
+getput.
+
+(1,1) holds the end-of-line character.
+(1,2) holds the current x coordinate.
+(2,1) holds the current y coordinate.
+(2,2) holds the beginnning-of-last-line-of-file character.
+
+This program is literally spaghetti code.  It basically works by getting itself
+with 135 degree turns, but it uses a few kludges to work around the data in the
+top-left.  Warning: trying to read the code may cause significant loss of
+sanity.  Oh wait a moment, you didn't have any in the first place.  Ok, go
+ahead, read the code, but don't blame me.
+
+Algorithm:
+1.  Get (1,1) and output (the first line must consist of just one character).
+2.  Push '\n'=10 (with "left, left, left, right, left, right, left, right,
+    left, right, left, right, left, right, left, right, left, right, left,
+    right, left, right, right") and output.
+3.  Put 3 in (2,1).
+4.  Put 1 in (1,2).
+5.  Get (1,3), which was equal to (2,1) at startup, and output.
+6.  Get (2,2) and output (the second line may have only have two characters).
+7.  Push '\n'=10 again (I didn't save it in step 2) and output.
+8.  Get (1,2).
+9.  Get (2,1).
+10. Get the character specified by the two coordinates at the top of the stack.
+11. Output it.
+12. Get ((1,2),(2,1)) again.
+13. Get (1,1) and compare.
+14. If equal, go to step 19, otherwise continue with step 15.
+15. Get (1,2).
+16. Increment.
+17. Put it back.
+18. Return to step 8 and repeat the whole process.
+19. This is a no-op step to remind you that you can only get here from the
+    conditional in step 14, not from step 18.
+20. Put 1 in (1,2).
+21. Push '\n'=10 (yes, I should save it somewhere, but place is limited,
+    particularly in this quine where special locations need special treatment)
+    and output.
+22. Get (1,(2,1)).  Note that this is the first character of the just-finished
+    line.
+23. Get (2,2) and compare.
+24. If equal, quit the program.  If unequal, continue to step 25.
+25. Get (2,1).
+26. Increment.
+27. Put it back.
+28. Return to step 8.
+And that's making it sound simpler than it really is.
+
+As it happens, the Wierd logo is 42 characters wide.  Also, the asterisk, which
+is the traditional wire character (although it is not treated specially by the
+computer), has ASCII code 42.  Is Wierd the answer to life, the universe, and
+everything (or to anything, for that matter)?

doc/random.doc.txt

+Special data:
+(1,1): The number so far (starts at 0).
+(2,2): The negative of the bit to be set (starts at -1).
+
+(2,2) is doubled each time, and tested for zero.  This is an overflow trick that
+only works on binary computers, and if Wierd is ever ported to ternary
+computers, this program will run indefinitely or at least much longer than it
+should.
+
+In detail:
+1.  Put 0 in (1,1).
+2.  Put -1 in (2,2).
+3.  Get (2,2).
+4.  Push zero (dance "left left right") and subtract.  This is necessary because
+    a condition can only follow a 45 or 315 turn (there needs to be space for
+    turning back).  Following a 45 turn is quite useless though...
+5.  Test.  If zero, go to step 17.  Otherwise, continue to step 6.
+6.  Use a 45/315 split to randomly chose whether or not the bit is to be
+    included in the number.  Depending on the result, either continue to step 7
+    or jump to step 11.
+7.  Get (1,1).
+8.  Get (2,2).
+9.  Subtract (see why (2,2) is negated now?).
+10. Put the result back in (1,1).
+11. Get (2,2).
+12. Push a zero through the "left left right" dance.
+13. Get (2,2) again.
+14. Subtract twice.
+15. Put the result in (2,2).
+16. Go back to step 3.
+17. Get (3,3) and put in (2,2) (for output subroutine).
+18. Output as a binary number, using output.w.
+19. Done!
+
+Since the output routine is O(n), you should modify the interpreter to use a
+smaller data type (short or even char) if you want the program to terminate this
+year.  Of course, since outputted number is random, you just might be lucky and
+get a very small number which can be printed in less than a second.  The random
+number generation itself is quite fast.

doc/wierdspec.txt

+Specification for the Wierd Programming Language--A MicroFunge
+
+First, a Riddle:
+Q:  What do you get when you put three marginally-sane programmers on a
+    mailing list with the Befunge and BrainF*** programming languages?
+A:  You get BeF***, and then they get Wierd.
+No, it's not really funny unless you already know what we're talking
+about.  So let's get you up to speed.
+
+History:
+The now-defunct Befunge Mailing List once questioned if Befunge was too
+"top-heavy" a language--that is, if its instruction set was needlessly
+large.  This, as one might expect (especially one reading this
+specification), quickly degenerated into an argument of "my language is
+smaller than yours."  Ben Olmstead managed to trim down Befunge to a
+lean seven instructions, dubbing the creation "BeF***".
+Not to be outdone, it was quickly suggested by John Colagioia that
+instructions, per se, be eliminated in favor of the "visual programming"
+aspect of Befunge:  The angles made by sequences of instructions.  Such
+a language, of course, would have a single "instruction" from the
+syntactic standpoint, although it surely cheats by horribly abusing
+the concept of Euclidean geometry.
+Chris Pressey then jumped on it, created the angle-to-instruction
+mapping, and christened the entire mess "Wierd"--a cross between the
+words "weird" (which the language seemed to be) and "wired" (which
+would describe the appearance of programs written in the language).
+
+The Basics:
+Wierd, like Befunge, is a two-dimensional language with a rectalinear
+grid of instructions which manipulate a system stack area.  Where
+Befunge has discrete, textual instructions, however, Wierd has a more
+implicit instruction set, each instruction denoted, not by a symbol, but
+by a configuration of symbols relative to the current direction of the
+instruction pointer:  the angle of deviation from "straight ahead" from
+the IP's perpsective.  That is, reading from left to right, the
+following program contains a single instruction:
+                             ******
+                                   *
+                                    *
+                                     *
+and the instruction is "read" as a 45-degree angle to the right.
+
+The Details:
+A Wierd source file can be any file, as the language only distinguishes
+between two symbols:  Whitespace and everything else.  A chain of non-
+whitespace symbols makes a Wierd program.
+Execution begins with the first character of the file (typically
+considered to be the "upper left" of the program), and the initial
+direction of the Instruction Pointer is down and to the right.  This was
+chosen to allow the programmer to get away from the corner as
+efficiently as possible, which reduces the risk of the program becoming
+trapped.
+Newlines are defined in a system-dependant manner, though it can be
+safely assumed on most systems that a carriage return and/or line feed
+character delineates the end of each line and begins the next.
+Execution then passes from character to character, in the specified
+direction until a turn needs to be made.
+
+Inertia:
+Like water, the Wierd IP takes the path of least resistance when
+confronted with a choice.  If the Wierd program branches, the IP will
+always choose the path which is closest to the direction it is already
+travelling.  Therefore, the following code (assuming the IP starts at
+the left, and travels to the right, like the above):
+                             ***********
+                                  *
+                                   *
+                                    *
+will stay on the top line, and never travel down the branch shown.
+Should the IP be faced with two equally-likely choices, the branch
+chosen by the interpreter is undefined, except for one condition which
+will be treated later.
+
+(Though, as an implementation note, it should be pointed out that the
+ only existing interpreter at this time chooses the left-hand path.
+ Note that Wierd was not intended to be left-handed, specifically; this
+ is just how the coin showed during the design phase--literally).
+
+Gap-Jumping:
+While the above is suitable for a fully-featured programming language,
+it was quickly realized that programmers could easily (possibly
+certainly) "paint themselves into a corner," where programs beyond a
+certain complexity might simply be impossible to write, and would at
+least be extremely impractical.
+Therefore, in keeping with the pseudo-electronic motif, the Instruction
+Pointer was given the ability to launch itself over a limited distance
+of unused ("empty") programspace to attach to a new program segment.
+This jumping, to keep it only used in emergency situations, is only
+usable over a maximum distance of two cells in the program grid.
+Gap-Jumping follows the same rules as typical movement, regarding
+Inertia.  That is, the IP will choose paths to jump into by how much of
+a change of direction is required to reach it.
+Note that jumping a gap into an isolated instruction, like in the
+following code segment:
+                               ***** *
+is considered an error.
+
+The Instructions:
+The Wierd instruction set is based on that of Befunge, though reduced to
+a nearly-absurd minimalism, and with a certain amount of "stack abuse,"
+in addition to the abuses already heaped upon the program's geometry.
+While the People for the Ethical Treatment of Data Structures threatened
+to protest, they quickly realized that their acronym was not easily
+pronounced, and retreated to debate the merits of a new name before
+further business could be discussed.
+The instructions, listed by angle, are:
+  0 degrees     NO:  No operation, continue as normal.
+ 45 degrees     P1:  Push a data value of 1 onto the stack.
+ 90 degrees     IF:  Pop the stack.  If the value is zero, continue
+                     executing as normal.  If the value is nonzero,
+                     however, reverse direction.
+135 degrees     GP:  Pop the stack.  If the value is zero, pops the next
+                     two items from the stack, retrieves (gets) the
+                     value stored at the coordinates specified by these
+                     values (x, then y), and push it onto the stack.  If
+                     the first value was nonzero, however, takes the
+                     value stored below the coordinates on the stack,
+                     and stores (puts) it at the coordinates.
+180 degrees     QU:  Jump the gap, if possible.  Otherwise, terminate.
+225 degrees     IO:  Pop the stack.  If the value is zero, read a
+                     character from input, pushing it onto the stack.
+                     If the value was nonzero, pop the stack, and print
+                     the value to output as a character.
+270 degrees     IF:  See 90 degrees.  Included for flexibility.
+315 degrees     SB:  Subtract the top of the stack from the value
+                     beneath it, popping both values, and pushing the
+                     result.
+Note that pushing a 1 is the only form of direct data specification
+available to the programmer, and subtraction is the only available
+arithmetic operation.
+
+Concurrency:
+The exception mentioned above to the "always choose a single path" rule
+is when the two likeliest paths are at angles of both 90 and 270
+degrees--both forms of conditional.  In such a case, rather than
+choosing one or the other, both paths are chosen, and the IP is cloned
+(including stack) to cover the other path.
+
+0                   ******
+ *                 *    *
+  *               *    *
+   *             *    *
+    *************    *
+                    *
+        ******      *
+       *      *     *
+      *        *    *
+     *          *   *
+    *****       *    *
+         *      *     *
+          *     *      *
+           *     *      *
+            *     *      *
+             *     *      *
+              *     *      *
+               *     *     *
+                ****  *    *
+                  *    *    *
+                 *      *    *
+                *        *    ****
+               *          *       *
+                           *       *
+                            *       *
+                             *********
+
+*                          *****************
+ *                         *               *    
+  *                        *      **       *
+   *                       *     *  *      *
+    *                      *    *    *     *
+     *                     *    *     *    *
+      *                    *   *       *   *
+       *                   *  *         *  *
+        *                  * ***************
+         *                 *              *
+          *                *               *
+           *               *                *
+            *              *                 *
+             *       **********               *
+              *      *     *  *   *********** *
+               *     * *   *  *   *         * *
+                *    * **   * *   *  ****** *  **
+                 *   * * *   **   * *    *   *   **
+                  *  ***  **  *   **    *    *     *
+                   *        *  *  *    *      *    *
+                    *       *   *     *        *   *
+                     *  ****     *****          *  *
+                      **                         *  *
+                                                  ****
+*                   ******
+ *                 *    *
+  *               *    *
+   *             *    *
+    *************    *
+                    *
+                    *
+             **************
+              *     *
+               *    *
+                *    *
+                 *    *
+                  *    *
+                   *    *
+                    *    *
+                    *     *
+                    *      *
+                     *     *
+                      *    *
+                       *    *
+                        *    *
+                         *    ****
+                          *       *
+                           *       *
+                            *       *
+                             *********
+
+*     ******
+ *   *    *
+  ***    *
+        *
+       *
+     * *
+      **
+       *
+
+*         ******
+ *       *    *
+  *     *    *
+ * *   *    *
+*   ***    *
+ **       *
+   *     *
+   *    *
+   *   *
+   *   *
+   * ***
+   **  *
+
+*              ******             *
+ *            *    *             * *
+  *          *    *             *   *
+   **********    *             *     *
+                *             **      *
+               *             * *
+              *             *  *
+              *            *    *
+              *            *     *
+              *            *     *
+              *            *     *
+              *            *     *
+       ********************************************
+              *            *     *                *
+              *            *     *                *
+              *            *     *                *
+              *            *     *                 *
+              *            *     *                  *
+              *            *     *                   *
+              *            *     *                   *
+              *            *     *                   *
+              *            *     *                   *
+       ****************    *     *                  *
+      *       *        *    *     *                *
+     *        *         *    *     *              *
+    *         *          *    *    *             *****
+    *         *        ****    *   *                  *
+    *          *      *         * *                    *
+    *           *    *           *                      *
+    *            ****           * *                      *
+    *                          *   *                      *
+    *                         *     *                      *
+    *                        *       ************************
+    *                       *
+    *                      *
+    *                     *
+    *                    *
+    *                   *
+    *                  *
+    *                 *
+    *                *
+    *               *
+    *              *
+    *             *
+    *            *
+    *           *
+    *          *
+    *         *
+    *        *
+    *       *
+    *      *
+    *     *
+    *    *
+    *   *
+    *  *
+    * *
+    **
+    *
+
+*
+ *
+  *
+   *
+    *
+     *
+      *
+       *
+        *
+         *
+          *
+           *              ******             *
+          * *            *    *             * *
+         *   *          *    *             *   *
+        *     **********    *             *     *
+       *                   *             **      *
+      *                   *             * *
+     *                   *             *  *
+    *                    *            *    *
+   *                     *            *     *
+    *                    *            *     *
+     *                   *            *     *
+      *                  *            *     *
+       *            ******************************************
+        *          *     *            *     *                *
+         *         *     *            *     *                *
+          *       *      *            *     *                *
+           *      *      *            *     *                 *
+            *      *     *            *     *                  *
+             *    **     *            *     *                   *
+              *  *       *            *     *                   *
+               * *       *            *     *                   *
+                *        *            *     *                   *
+                  ****************    *     *                  *
+                 *       *        *    *     *                *
+                *        *         *    *     *              *
+               *         *          *    *    *             *****
+               *         *        ****    *   *                  *
+               *          *      *         * *                    *
+               *           *    *           *                      *
+               *            ****           * *                      *
+               *                          *   *                      *
+               *                         *     *                      *
+               *                        *       ************************
+               *                       *
+               *                      *
+               *                     *
+               *                    *
+               *                   *
+               *                  *
+               *                 *
+               *                *
+               *               *
+               *              *
+               *             *
+               *            *
+               *           *
+               *          *
+               *         *
+               *        *
+               *       *
+               *      *
+               *     *
+               *    *
+               *   *
+               *  *
+               * *
+               **
+               *
+
+0
+ 9
+  *
+   *
+    *
+     *          PUT
+      *
+       *         *
+        *        **
+         *       * *
+          *      *  *
+           *     *   *
+            *     *   *
+             *     **********************************
+              *         *                            *
+               *         ***                          *
+                *           *                          *
+                 *           *                          *
+                  *          *                           *
+                   *         *                            *
+                    *     **************                   *
+                   * *   *   *          *                   *
+                  *   * *    *           *                   *
+                 *     *     *           *                    *
+                *     * *   *            *            ***      *
+               *     *   * *      GET **********   ***   *      *
+              *     *     *       END  * *      ***      *       *
+             *     *     * *            **                ***     *
+            *     *     *   *            *                   ***   *
+           *     *   ***     *           *                      *   *
+          *     *   *         *          *                      *    *
+         *     *   *  ADD ONE  *         *                     *      *
+        *     *    *            *  DONE? *                    *        *
+       *     *     *             *       *                   *          *
+      *     *     *               *      *                  *            *
+     *     *     *         ***************                 *              *
+    *     *      *                  *           * GET     *                *
+   *     *       *                   *         **        *                *
+  *     *       *                     *       * *       *                *
+ *     *********                       *     *  *      *                *
+*                                       *   *   *     *                *
+ *     GET AGAIN                         * *    *    *                *
+  ***                                     *     *   *                *
+     *                                   * *   *   *                *
+      *                                 *   ***   *                *
+      *                                *         *                *
+      *                            *** *        *                *
+      *                           *   **       *                *
+      *                          *     *      *                *
+      *                          *           *                *
+      *                          *   WRITE  *                *
+      *                          *         *                *
+      *                          *        *                *
+      *                          *       *                *
+      *                          *      *                *
+      *                          *     *                *
+      *                          *    *                *
+      *                          *   *                *
+      *   ***                    *  *                *
+      *  *   *                   * *                *
+      ***     *                  **                 *
+               *                 *                  *
+                *                                    *
+                 *           GET AGAIN                *
+                  *                                   *
+                   *         **************************
+                    *       *
+                     *     *
+                      *    *
+                       *   *
+                        * *
+                         *
+
++                *
+ *               **
+  *              * *
+   *             *  *                  **
+    *      ****************************  *
+     *     *     *    *                   *
+      *    *     *     *                   *
+       *   *     *     *                    *
+        *  **RESTART***                      *
+         *       *   *                        *
+          *  **LOOP**                          *
+           **    *                  *           *
+                 *                  **        *  *
+                  **                * **      **  *
+                    * *****         *   *     * *  *
+                     *     *        *   *     * *   *
+                    * *    * ***********    ****     *
+                   **********       *      *  *       *
+                        *  *        *      *  *        **
+                         * *      ******* *    *         *
+                          **     *  *  *  *  *********** *
+               **          *     *   **  *  *    *    *  *
+            ***  **        *    *       *   *     *  *   *
+            *      *       * ***********   *      *  *   *
+            *   **DEHSINIF** *              *      **    *
+            *  *   *         F               *           *
+            *  *   *         I                *  *********
+            *   ** *         N                 **
+            *     **         I
+            *      *         S
+            *                H
+            *              **E*****
+             ***          *  D   *
+                *         *  *  *
+              *********    * *  *
+             *    *   *   **  **
+             *     *  *  *
+            *       *  * *
+             *       * * *
+              *       *  *
+               *        *
+                *        *          **
+                 ******************* *
+                                      **
+                                        *
+                                       *   *
+                                       *  * *
+                                        * *  *
+                                        * *   D
+                                        **     O
+                                                N
+                                                 E
+                                                  !
+                                                   *
+                                                    *
+
+H          ************************             ******************                                                 **********
+ e         *                      *            *                  *                                        *       *        *
+  l        *      ***             *             **                 *                                      * *      *        *
+!  o       *   ***   *          * *               *                 *                                     *  *     *        *
+    ,      *  *       *        ** *               *                 *                                    *    *    *      * *
+     W      * *        *      * * *               *                 *                                    *     *   *     ** *
+      r      *          *    *  * *               *  ************   *                                   *       *  *    * * *
+       d                 *  *   * *               * *          *    *                                  ******    *  *  *  * *
+        *                 * *   * *               **         **     *                                        *    *  * *  * *
+         *                 **   * *               *         *       *                                         *    *  ** *  *
+          *                 *   * *                         *       *                   **  **                 *    *  * *  *
+           *                    * *                        *        *                 **  ** *              **  *    *   *  *
+            ********************  *                        *        *               **       *            **  ****    ***   *
+                                   *              **      *         *             **         *          **                  *
+                                    *           **  *     *        *            **           *        **                    *
+                                     *        **     *  **        *       **  **             *      **                     *
+                                      *****  *        **         *       *  **                **  **                      *
+                                           **                   *        *                      **                       *
+                                                               *          *                                             *
+  *************************************************************           *                *****************************
+ *                                                                       *                *
+ *                                          ***                         *                *
+*                   *                       *  *                       *                *
+*                   **                       *  *                     *                *
+ *                  * *                      *   **                  ******           *        *********************
+ *                  * *                     *      *                       *          *       *                     *
+  *                 *  *                    *      *                        *        *        *                      *
+  *                 *  *                   *        **                       *       *         *                      *
+   *                *   *                 *           **                      *       *        *                       *
+   *                *   *                *****          **                     *      *       *                         *
+    *               *    **                   *           **               **   *      *     *                           *
+    *               *      **                  *            **           **  *****     *    *                            *
+   *                *        **                 *             *        **               *   *                            *
+  *                 *          **           **   *            *      **                 *    **                          *
+  *                 *            *        **  *****            **  **                    *     **                        *
+   *                *            *      **                       **                      *       *                       *
+   *                *             **  **                                                  *       *                      *
+    **              *               **                                                    *        **                    *
+      *             *                                                                      *         *                   *
+       *            *  *************************************************************       *         *                   *
+        **          *   *                                                           *       *         *                  *
+          **        *    *                                                        *  *      *         *                  *
+            *      *      *                          *************************   **   *    *          *                  *
+             *     *       *                        *                       *   * *    *   *          *                  *
+              ***  *        *                       *      *               *   *  *     *   *         *  **************  *
+                 * *         *                     *       **             *   *   *      *  *  **      **             *  *
+                 * *          *                    *       * *  ***      *   *    *       *  **  **             *******  *
+                  **           *                    *      *  **        *   *     *        *       **            *       *
+                   *            *                   *      *           *   *      *         *        **           *      *
+                                 *                   *     *          *   *       *          *         **          *     *
+                                  *                  *     *         *   *        *           *          **        *     *
+                                   *                  *    *        *   *  *      *            *           **      *     *
+                                    *                 *    *        *  *   **     *             *            **    *     *
+                                     *                 *   *        *  *  *  *    *              *             *   *     *
+                                      *                *   *        *  * *   *    *               *            *   *     *
+                                       *                *  *        *  **    *    *                *            *  *     *
+                                        *               *  *        *  *     *    *                *             * *     *
+                                         *             *   *        *        *    *                *              **    *
+                                          *           *   *          *       *    *                *               *   *
+                                           *         *   *            *     *     *                *                  *
+                                            *       *   *              *****      *                *                 *
+                                             *      *  *                          *                *                *
+                                              *     * *                           *                *               *
+                                               *    **                           *                 *              *
+                                                *   *                           *                 *               *
+                                                 *                             *                 *                *
+                                                  *****************************                 *                  *
+                                                                                               *                   *
+***********************************************************************************************                     *
+*                                                                                                                   *
+*                                                                                                                    *
+*                                     **                                                                             *
+*                                   **  **                                                                          *
+*                                 **      *                                                                        *
+*                               **        *                                                                        *
+*                             **          *                                                                         *
+*                           **            *                                                                         *
+*                         **              *  ******                                                                *
+*     ****              **                * *    *                                               ******************
+*    *    *       **  **                  **    *                                               *
+*    *    *     **  **                    *   **                                                *
+*   *     *    *                             *                                                  *
+*  *      *    *                             *                                                 *
+* *****    *  *                             *                                                  *
+*     *     * *                             *                                                   *
+*     *      **                            *                                                    *
+*     *       *                            *                                                     *
+*     *                                   *                                                      *
+*******                                   *                                                       *
+                                    **  **                                                        *
+                                  **  **                                                           *    *
+                        **      **                                                                 *    **
+************************  **  **                                                                    *   * *
+*                           **                                                                      *   *  *
+*  *                                                                                               *   *    *
+*  **                                                                                             *   *    *
+*  * *                                                                                            *  *    *
+*  *  *                                                                                           * *    *
+* *   *                                                                                           **    *
+* *    **                                                                                         *    *
+* *      **                                                                                           *
+* *        **                                                                                        *
+ **          **                                                                                     *
+  *            **                                                     ******************************
+                 **                                             **  **
+                   **                                         **  **
+                     **  **                                 **
+                       **  *                              **
+                           *                            **
+                            *                         **
+                            *                       **
+                           *              **  **  **
+                           ***************  **  **
+   **
+
+                           *              **  **  **
+
+                           ***************  **  **
+
+
+*
+ *
+  *
+   *
+  * *  **
+ *   ** *
+  **     **
+    *      *
+    *     *
+    *     *
+    *      *
+    *     **
+    *    *
+    * ** *
+    **  *
+
+*                      *
+ *                    * *
+  *                  *   ***
+   *                 *      *
+    *                *       *
+     *                *      *
+      *                *     *
+       *               *     *
+        *            ***     *
+         *          *        *
+          *        *         *
+           *       *         *
+            *      *         *
+             *    *          *
+              *  *           *
+               *  *          *
+                *  *         *
+                 *  *      ***
+                  *  *    *
+                   *******
+
+&        *
+ 0      * *
+  *     *  *
+   *  **    *
+    **       *
+              *              ****************************
+               *  ***********                            *
+                * *                                       *
+                 **               *                        *
+                  *               **                        *
+                  *H              * *                        *
+                  * A             *  *                  **    *
+                  *  L      ****************************  *    *
+                  *   F     *     *    *                   *    *
+                  N    *    *     *     *                   *    *
+                  E     *   *     *     *                    *    *
+                  X      *  **RESTART***                      *    *
+                  T       *       *   *                        *    *
+                  *     *  *  **LOOP**                          *    *
+                  *    * *****    *                  *           *    *
+                  *    *          *                  **        *  *    *
+                  *  **            **                * **      **  *    *
+                  *  *               * *****         *   *     * *  *    *
+                  *   *               *     *        *   *     * *   *    *
+                   ** *              * *    * ***********    ****     *    *
+                     *              **********       *      *  *       *    *
+                                         *  *        *      *  *        **   *
+                                          * *      ******* *    *         *   *
+                                           **     *  *  *  *  *********** *  *
+                                **          *     *   **  *  *    *    *  *  *
+                             ***  **        *    *       *   *     *  *   *  *
+                             *      *       * ***********   *      *  *   *  *
+                             *   **DEHSINIF** *              *      **    *  *
+                             *  *   *         F               *           *  *
+                             *  *   *         I                *  *********  *
+                             *   ** *         N                 **           *
+                             *     **         I                              *
+                             *      *         S                              *
+                             *                H                              *
+                             *              **E*****                         *
+                              ***          *  D   *                          *
+                                 *         *  *  *                           *
+                               *********    * *  *                           *
+                              *    *   *   **  **                            *
+                              *     *  *  *                                  *
+                             *       *  * *                                  *
+                              *       * * *                                  *
+                               *       *  *                                  *
+                                *        *                                   *
+                                 *        *          **            *         *
+                                  ******************* *            **        *
+                                                       **          * *       *
+                                              *  **      *         * *       *
+                                             * ** *     *   *      *  **     *
+                                            *      **   *  * *     *    **   *
+                                            *        *   * *  *    *      *  *
+                                         ***        *    * *  **   *      *  *
+                                         *         *     **     *  *     *   *
+                                         *     ****              H *     *   *
+                                          *   *  * *              A*      *  *
+                                          *  *  **OREZ**           L      *  *
+                                ****PRINT*  *  *   *   *           *V      * *
+                                 *         *   *   *   *           * E     * *
+                                  *       *     ** *   **          *  D  **  *
+                                  *      *        **   * **        *   **    *
+                                 *************     *   *   *       *         *
+                                * *    *  *  *         *   *       *         *
+                                * *   *  *   D         *  **IICSA**          *
+                                 **  *   *   O         * * *                 *
+                                  * *****    N         * * *                 *
+                                             E         *  **                 *
+                                             *          *  *                 *
+                                             (           *                   *
+                                             P            **                 *
+                                             R              *                *
+                                             I             *                 *
+                                             N             *                 *
+                                             T              *                *
+                                             *              *                *
+                                             N              *                *
+                                             E              *****************
+                                             W
+                                             L                    **
+                                             I                  **  ****
+                                             N                **      *
+                                             E              **       *
+                                             )            **        *
+                                             *          **         *
+                                             *        **
+                                             *      **
+                                             *    **
+                                             *  **
+                                              **
+
+DONOTWierd                                            *
+DO,1<-                                        #      0 09
+DO,1SUB#1                                    <-      #   01        10
+PLEASEDO,1SUB                               # 2    <-      #0     3  2
+DO,1SUB                                    #  3  <-          #0   7   2
+    DO                  ,1SUB#004<-#0     0   0  0             000000136
+DO,1SUB#5             <-             #   0    0   0               8     8
+PLEASEDO,1SUB         #         06   <- #     0   1               3    6
+       DO            ,    1SUB#7  <-   #   000   0                6    4
+DO ,01 SUB          #8    <-        # 0 0  0     0                0     80
+DO ,1   SUB        #     00         0 0  0  0   9                <-#2     26
+          PLEASE  READ  OUT       ,0  0   0 0   0 000000000000000 0  0      01
+PLEASEGIVEUPDONOTBOTHERME *      *    *   P *  *   *              *  *        **
+DONOT        *  *         *      *    *  O* *  *    *             * *           **
+DONOT         **          *     *     * O **  *      *  **        * *             **
+DONOT         **          *     *     *L  *   *       ** *        *  *              **
+PLEASEDONOT  *  *         *    *      *  **  *            **      *  *                **
+DONOT       *    *        *    *     N* * * *               *     *   *                 **
+DONOT      *      *       *   *     I **  **               *      *   *                   **
+DONOT     *        *      *   *    A  *   *                *      *  *                      *
+PLEASEDO NOT        *     *  *    M  **  **                 *     * *                       *
+DONOT    *           *    *  *   *  * * * *                **     **                         *
+DONOT   *             *   * *   *  *  **  *        **     *       *           *****************
+DONOT    *             *  * *  *  *   *   *********  * ** *
+PLEASEDONOT             ****  *  *   **              **  *
+DONOT      *  **          *  *  *   * *
+DONOT       ** *          * *  *   *  *
+DONOT          *          **  *   *   *
+PLEASEDONOT    *          *  *   *    *
+DONOT         ***********   *   *     *
+DONOT        * *         * *   *      *
+DONOT        * *          *   *       *
+PLEASEDONOT  * *         * * *        *
+DONOT        * *        *   *         *
+DONUT        * *       *   * *        *
+DONOT        * *      *   *   *       *
+PLEASEDONOY  * *     *   *     *      *
+DONOT        * *    *   *       *     *
+DONOT        * *   *   *         *    *
+DONOT        * *  *   *           *   W
+PLEASEDONOT  * * *   *             *  R
+DONOT        * **   *               * I
+DONOT        * *   *                 *T
+DONOT        *    *                   E
+DONOT        *   *
+OKAY,DOIFYOUPLEASE!
+ICHANGEDMYMINDDON'T
+DONOTDOTHAT  **
+PLEASESTOP   *
+
+!
+ @
+  *         !
+   *       *!
+    *     * !
+     *   *  !
+      * *   *                            !
+       *   *                            * !
+      * ***                            *   !
+   ** *                               *     !
+  *  **          **                  *       **!
+  *   *        **  ****             *   *       !
+ *           **      *             *    **       !
+ *         **       *             *     * *      !
+*        **        *       *     *      *  ***   *                                        !
+*      **          *      * *   *       *     *   *                                      * !
+ *   **            *     *   * *        *      *   *                                     *  *            !
+ * **               *    *    *   **    *      *   *                                      *  *           *!
+ **                  *   *   * *** *    *      *   *                                      *   *          * !
+                     *  *   *      *    *     *   *                                       *    *         *  !
+                     ***   *        **  *    *   *                                        *     *        *   !
+                          *           * *    *   *                                        *      *       *    !
+                         *           *  *    *   *                 *                      *       *      *     !
+                        *           *   *     *   *                **  ***                *        *     *      !
+                       *            *    *     *   *               * **  *                *         *    *       !
+                      *              *    *    *   *               *      ****            *          *   *        !
+                     *              **     *   *   *              *           *           *           **************************!
+                    *              *        *   *   *             *          *            *              *          *            !
+                   *               *         *   *   *             *         *            *              *           *            !
+                  *               *           *  *   *             *          *           *              *            *            !
+                 *               *             * *   *              *         *           *              *  ********************** !
+                *               *               *   *               *         *           *              * *          *         *  !
+               *               *           ***** ***  *              *        *           *              * *          *       **   !
+              *                 *         *           **             *        *           *              *  *         *      *     !
+             *                   *        *           * *             *       *           *              *  *    **** *  *   *     !
+            *                     *      *            * *             *       *           *              *   *  *  *  * **  *      !
+           *                       *     *            *  **            *      *           * *            *   * ********* *  *      !
+          *                         *   *              *   **          *      *           * **           *  *    *    *   **       !
+         *                           *  *              **    **         *     *           * * *          *  *   *     *            !
+        *                             **              *        *        *     *           * * *          *   * *      *            !
+       *                                              *        *         *    *           * *  **        *    *       *            !
+      *********************************************************          *    *           * *    **      *   * *      *            !
+                                                      *                   *   *           * *      *     *  *   *     *            !
+ __          ___________________   _____               *                  *   *           * *      *     * *     *    *            !
+ \ \        / __   __   ___   _ \ |  __ \              *                   *  *           *RESTART*      **    *  *   *            !
+  \ \  /\  / /  | |  | |_  | |_) \| |  \ \              *                  *  *             *    *       *    **   *  *            !
+   \ \/  \/ /   | |  |  _| |  _  /| |   ) )             *                   * *        **RESTART*       **   * *    * *            !
+    \  /\  /  __| |__| |___| | \ \| |__/ /             *                    * *        *    *  *       * *  *  *     **            !
+     \/  \/  |_______________|  \_______/              *    ****************  ****MAIN*LOOP****       *  * *   *      *            !
+      ____    _   _____________     ____                **   *                         *    *    **  *   **    *                   !
+     / __ \  | | |  __   __    \   |  __|                 **  *                        *    *  **  **    *     *                   !
+    / /  \ \ | | | |  | |  | |\ \  | |_                     * *                        *     **         **     *                   !
+   ( (    ) )| | | |  | |  | | \ \ |  _|                    * *                        *   *           * *     *                   !
+    \ \__/  \| |_| |__| |__| |  \ \| |__                     **                        *  * ****YAW*SIHT****** *                   !
+     \____/\_________________|   \______|                     *                        * *   *       *   *  *  *                   !
+                                                                   ********WON*1=X**** **     * *****     **   *                   !
+   ____     ____    ___      ___     ___                          *                 *  *       *   * *        *                    !
+  / __ \   / _  \  / _ \    / _ \   /   |                         *                *  **      * * *   *       *                    !
+ / /  \ \ (_/ ) / / / \ \  / / \ \ (_/| |                          *               * E *     *   *     *       *                   !
+( (      )   / / ( (   ) )( (   ) )   | |                          *               *O  *   **   * *     *      *                   !
+ \ \__/ /   / /__ \ \_/ /  \ \_/ /  __| |__                         *              L   *  *     *  *     *      *                  !
+  \____/   /_____| \___/    \___/  |_______|                        *             **   *  *      *  *     *     *                  !
+  __        ____    ___      ___     ____                            *           * *   * *       *   ***********                   !
+ /  \      / _  \  / _ \    / _ \   / _  \                           *          *  *   * *        *         *                      !
+( () ) _  (_/ ) / / / \ \  / / \ \ (_/ ) /                            *        *   *   *  *       *          *                     !
+ ) _ \/ )    / / ( (   ) )( (   ) )   / /                             *       *  **    ****      *    **  *****                    !
+( (_)  (    / /__ \ \_/ /  \ \_/ /   / /__                             *     *  *                *  **  **                         !
+ \___/\_)  /_____| \___/    \___/   /_____|                            *    *   *                 **                               !
+     __      ____________        ____                                   *  *   *                                                   !
+    |  \    /   __   __  |      / __ \                                  *  *   *                                                   !
+    |   \  /   |  | |  | |     / /  \ \                                  *  ***                                                    !
+    | |\ \/ /| |  | |  | |    ( (    ) )                                 *                                                         !
+    | | \  / | |__| |__| |_____) \__/ /                                   *                                                        !
+    |_|  \/  |_______________________/                                    *                                                        !
+           __          ___     _                                           *                                                       !
+           \ \    /\  |   \   | |                                          *                                                       !
+            \ \  /  \ | |\ \  | |                                           *                                                      !
+             \ \/ /\ \| | \ \ | |                                           *                                                      !
+              \  ____ \ |  \ \| |                                          *                                                       !
+               \/    \__|   \___|                                          *                                                       !
+ _    _         ___     _____   _______                                  ***                                                       !
+| |  | |   /\  |   \   |  __ \ |  ___  |                                *  *                                                       !
+| |__| |  /  \ | |\ \  | |  \ \| |_  | |                                *                                                          !
+|  __  | / /\ \| | \ \ | |   ) )  _| | |                                 *            *                                            !
+| |  | |/ ____ \ |  \ \| |__/ /| |___| |___                              *           * *                   *                       !
+|_|  |___/    \__|   \_______/ |___________|                              *         D   *                 **                       !
+                                                                          *        O     *               * *                       !
+ SOURCE AND OUTPUT BOTH LICENCED BY THE GPL                              *  *     N       *******       *  *                       !
+        (DOESN'T FIT WITH ASCII ART)                                     *  **   E         *   *       *   *                       !
+                                                                          * * *         *******       *    *                       !
+                                                                           ** *        *     *       *     *                       !
+                                                                            * *        *      N     *      *                       !
+                                                                            ***       *        O   *       *                       !
+                                                                            * *   **  *         T *      **                        !
+                                                                            *   **  **           *      *                          !
+                                                                             ***                * Y     *                         !
+                                                                                               *   E   *                         !
+                                                                                               *    T  *                        !
+                                                                                                *    **                        !
+                                                                                                *                             !
+                                                                                                 *                           !
+                                                                                                 *                          !
+                                                                                                *                          !
+                                                                                                *                           *!
+                                                                                                 **                           * *!
+                                                                                                   **                         **  !
+                                                                                                     *                             !
+                                                                                                     *  ****************************!
+@                                                                                                     *!
+
+
+
+*                              **            *
+ *       *                   **  *          **
+  0      **          ****  **    *         * *
+   *     * **     *   *  **       **       * *
+    *    *   *   **    *            **     * *
+     *   *   *  * *     *             **   *  *
+      *  * **  *  *      *              *  *  *
+       ****   *   *       *             *  * *
+         *   *     *       *           *   * *
+         *  *      *        *         *    *  *
+         * *      *          *       *     *  *
+         **       *           *     *      *   *
+         *         *           *   *       *   *
+        **         *            * *      ******
+       * *          *            *      *  *       *
+       * *          *           * *     *  *      * *
+       * *        **           *   *   *    *     *  *
+       * *       *            *     *  *    ******    *
+       * *       *           *       **                *
+       *  **    *   *       N            ********       *
+       *    **  *  * ******E*******     *       *        *
+       M      **  *       S        * ** *  **   *         *
+       A         *       O         **  *  *  *   *         *
+       I        *       H                 *   *   *         *
+       N       *       C                 *     *   *         *
+       *      *       *      *           *      *   *         *
+       L     *       R       **        **        *  *          *
+       O    *       E        * *      *           **            *
+       O   *       B         * *      *           **  *          *
+       P  *       M          *  **     *         *  ***           *
+       * *       U           *    **   *        *     *            *
+       **       N            *      *   *      *      *             *
+       *       *             *      *   *     *       *              *
+       *      *    **        *     *   *     *        *               *
+        **     ****  *       *     *   *    *        *                 *
+          **    *     *      *      *   *  *         *                  *
+            *    ****  *     *      *   * *           *                  *
+            *  ** *  ****    *       *  **            *                   *
+             **    *         *       *  *              *                   *
+                    *****************                  *                    *
+                    *        *     *                 **                      *
+                    *         *   *                 *                         *
+                    *          * *                  *                          *
+                    *           *                  *                            *
+                    *          * **                *                             *
+                    *         *    ****************                               *
+                    *       **                                                     *
+                    *       *                                                       *
+                   ******    *                                                       *
+                  * *  *     *                                                        *
+                  *  **     *                                                          *
+                   *         ***                                                        *
+                   *            *                                                        *
+                    *      **   *                                                         *
+                    *  ****  *  *                                                          *
+                   *    *    *  *                                                           *
+                   *     *   *  *                                                            *
+                    **    * *   *                                                             *
+                      **   *  ***                                                              *
+                        * * **                                                                  *
+                        * *                                                                      *
+                         **                                                                       *
+                          *                                                                        *
+                                                                                                    *        *
+                                                                                                     *      * *
+                                                                                                      *     *  *
+                                                                                                       *  **    *
+                                                                                                        **       *
+                                                                                                                  *              ****************************
+                                                                                                                   *  ***********                            *
+                                                                                                                    * *                                       *
+                                                                                                                     **               *                        *
+                                                                                                                      *               **                        *
+                                                                                                                      *H              * *                        *
+                                                                                                                      * A             *  *                  **    *
+                                                                                                                      *  L      ****************************  *    *
+                                                                                                                      *   F     *     *    *                   *    *
+                                                                                                                      N    *    *     *     *                   *    *
+                                                                                                                      E     *   *     *     *                    *    *
+                                                                                                                      X      *  **RESTART***                      *    *
+                                                                                                                      T       *       *   *                        *    *
+                                                                                                                      *     *  *  **LOOP**                          *    *
+                                                                                                                      *    * *****    *                  *           *    *
+                                                                                                                      *    *          *                  **        *  *    *
+                                                                                                                      *  **            **                * **      **  *    *
+                                                                                                                      *  *               * *****         *   *     * *  *    *
+                                                                                                                      *   *               *     *        *   *     * *   *    *
+                                                                                                                       ** *              * *    * ***********    ****     *    *
+                                                                                                                         *              **********       *      *  *       *    *
+                                                                                                                                             *  *        *      *  *        **   *
+                                                                                                                                              * *      ******* *    *         *   *
+                                                                                                                                               **     *  *  *  *  *********** *  *
+                                                                                                                                    **          *     *   **  *  *    *    *  *  *
+                                                                                                                                 ***  **        *    *       *   *     *  *   *  *
+                                                                                                                                 *      *       * ***********   *      *  *   *  *
+                                                                                                                                 *   **DEHSINIF** *              *      **    *  *
+                                                                                                                                 *  *   *         F               *           *  *
+                                                                                                                                 *  *   *         I                *  *********  *
+                                                                                                                                 *   ** *         N                 **           *
+                                                                                                                                 *     **         I                              *
+                                                                                                                                 *      *         S                              *
+                                                                                                                                 *                H                              *
+                                                                                                                                 *              **E*****                         *
+                                                                                                                                  ***          *  D   *                          *
+                                                                                                                                     *         *  *  *                           *
+                                                                                                                                   *********    * *  *                           *
+                                                                                                                                  *    *   *   **  **                            *
+                                                                                                                                  *     *  *  *                                  *
+                                                                                                                                 *       *  * *                                  *
+                                                                                                                                  *       * * *                                  *
+                                                                                                                                   *       *  *                                  *
+                                                                                                                                    *        *                                   *
+                                                                                                                                     *        *          **            *         *
+                                                                                                                                      ******************* *            **        *
+                                                                                                                                                           **          * *       *
+                                                                                                                                                  *  **      *         * *       *
+                                                                                                                                                 * ** *     *   *      *  **     *
+                                                                                                                                                *      **   *  * *     *    **   *
+                                                                                                                                                *        *   * *  *    *      *  *
+                                                                                                                                             ***        *    * *  **   *      *  *
+                                                                                                                                             *         *     **     *  *     *   *
+                                                                                                                                             *     ****              H *     *   *
+                                                                                                                                              *   *  * *              A*      *  *
+                                                                                                                                              *  *  **OREZ**           L      *  *
+                                                                                                                                    ****PRINT*  *  *   *   *           *V      * *
+                                                                                                                                     *         *   *   *   *           * E     * *
+                                                                                                                                      *       *     ** *   **          *  D  **  *
+                                                                                                                                      *      *        **   * **        *   **    *
+                                                                                                                                     *************     *   *   *       *         *
+                                                                                                                                    * *    *  *  *         *   *       *         *
+                                                                                                                                    * *   *  *   D         *  **IICSA**          *
+                                                                                                                                     **  *   *   O         * * *                 *
+                                                                                                                                      * *****    N         * * *                 *
+                                                                                                                                                 E         *  **                 *
+                                                                                                                                                 *          *  *                 *
+                                                                                                                                                 (           *                   *
+                                                                                                                                                 P            **                 *
+                                                                                                                                                 R              *                *
+                                                                                                                                                 I             *                 *
+                                                                                                                                                 N             *                 *
+                                                                                                                                                 T              *                *
+                                                                                                                                                 *              *                *
+                                                                                                                                                 N              *                *
+                                                                                                                                                 E              *****************
+                                                                                                                                                 W
+                                                                                                                                                 L                    **
+                                                                                                                                                 I                  **  ****
+                                                                                                                                                 N                **      *
+                                                                                                                                                 E              **       *
+                                                                                                                                                 )            **        *
+                                                                                                                                                 *          **         *
+                                                                                                                                                 *        **
+                                                                                                                                                 *      **
+                                                                                                                                                 *    **
+                                                                                                                                                 *  **
+                                                                                                                                                  **
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <getopt.h>
+
+typedef struct stack
+{
+   int value;
+   struct stack *below;
+} stack;
+
+typedef struct thread
+{
+   int id;
+   int x, y, dx, dy;
+   stack *stack_head;
+   struct thread *next, *prev;
+} thread;
+
+int size = 256;
+int debug = 0;
+int **world;
+thread *current_thread;
+int threads = 0;
+
+void push(int value)
+{
+   stack *new;
+
+   new = malloc(sizeof(*new));
+   new->value = value;
+   new->below = current_thread->stack_head;
+   current_thread->stack_head = new;
+}
+
+int pop(void)
+{
+   stack *old;
+   int value;
+
+   old = current_thread->stack_head;
+   if(old == NULL)
+   {
+      fprintf(stderr, "Insufficient stack!\n");
+      exit(1);
+   }
+   value = old->value;
+   current_thread->stack_head = old->below;
+   free(old);
+   return value;
+}
+
+void copy_stack(thread *dst, thread *src)
+{
+   stack *dst_loc, *prev_dst_loc = NULL, *src_loc;
+
+   if(src->stack_head == NULL)
+   {
+      dst->stack_head = NULL;
+      return;
+   }
+   for(src_loc = src->stack_head; src_loc != NULL; src_loc = src_loc->below)
+   {
+      dst_loc = malloc(sizeof(*dst_loc));
+      dst_loc->value = src_loc->value;
+      dst_loc->below = NULL;
+      if(prev_dst_loc == NULL) dst->stack_head = dst_loc; else prev_dst_loc->below = dst_loc;
+      prev_dst_loc = dst_loc;
+   }
+}
+
+void new_thread(void)
+{
+   thread *new;
+
+   new = malloc(sizeof(*new));
+   new->id = threads++;
+   new->x = current_thread->x;
+   new->y = current_thread->y;
+   new->dx = -current_thread->dx;
+   new->dy = -current_thread->dy;
+   copy_stack(new, current_thread);
+   new->next = current_thread->next;
+   new->prev = current_thread;
+   current_thread->next->prev = new;
+   current_thread->next = new;
+}
+
+void kill_thread(void)
+{
+   thread *old;
+
+   old = current_thread;
+   while(old->stack_head != NULL) pop();
+   if(old->next == old) exit(0);
+   old->prev->next = old->next;
+   old->next->prev = old->prev;
+   current_thread = old->next;
+   free(old);
+}
+
+void turn_dxdy(int *dx, int *dy, int direction)
+{
+   int old_dx, old_dy;
+
+   direction %= 8;
+   if(direction < 0) direction += 8;
+   while(direction-- > 0)
+   {
+      old_dx = *dx;
+      old_dy = *dy;
+      *dx = old_dy + old_dx;
+      *dy = old_dy - old_dx;
+      if(abs(*dx) == 2) *dx /= 2;
+      if(abs(*dy) == 2) *dy /= 2;
+   }
+}
+
+int can_turn(int direction)
+{
+   int dx = current_thread->dx, dy = current_thread->dy;
+
+   turn_dxdy(&dx, &dy, direction);
+   return world[current_thread->x + dx][current_thread->y + dy] != ' ';
+}
+
+void turn(int direction)
+{
+   turn_dxdy(&current_thread->dx, &current_thread->dy, direction);
+}
+
+void print_stack(void)
+{
+   char str1[256], str2[256] = "";
+   stack *printing;
+
+   fprintf(stderr, "The new stack is");
+   if(current_thread->stack_head == NULL)
+   {
+      fprintf(stderr, " empty.\n");
+      return;
+   }
+   for(printing = current_thread->stack_head; printing != NULL; printing = printing->below)
+   {
+      sprintf(str1, " [%d]%s", printing->value, str2);
+      strcpy(str2, str1);
+   }
+   fputs(str2, stderr);
+   fputc('\n', stderr);
+}
+
+void help(void)
+{
+   fprintf(stderr, "Valid options:\n");
+   fprintf(stderr, "-help:          Show this screen.\n");
+   fprintf(stderr, "-size <number>: Set the memory size.\n");
+   fprintf(stderr, "-debug:         Print debugging information.\n");
+   fprintf(stderr, "There should also be a non-option argument naming the program to be run.\n");
+   exit(1);
+}
+
+int main(int argc, char **argv)
+{
+   struct option options[] = {{"help",    0, NULL, '?'},
+                              {"size",    1, NULL, 's'},
+                              {"debug",   0, NULL, 'd'}};
+   int done = 0;
+   char *ptr;
+   int x, y;
+   char *in_name = NULL;
+   FILE *in_file;
+
+   opterr = 0;
+   while(!done)
+   {
+      switch(getopt_long_only(argc, argv, "-?", options, NULL))
+      {
+      case 's': if(*optarg == '\0') help();
+                size = strtol(optarg, &ptr, 10);
+                if(*ptr != '\0') help();
+                break;
+      case 'd': if(debug) help();
+                debug = 1;
+                break;
+      case '?': help();
+      case 1:   if(in_name != NULL) help();
+                in_name = strdup(optarg);
+                break;
+      case EOF: done = 1;
+                break;
+      }
+   }
+   if(in_name == NULL) help();
+   world = malloc(sizeof(*world) * size);
+   for(x = 0; x < size; x++)
+   {
+      world[x] = malloc(sizeof(**world) * size);
+      for(y = 0; y < size; y++) world[x][y] = ' ';
+   }
+   in_file = fopen(in_name, "r");
+   if(in_file == NULL)
+   {
+      perror(in_name);
+      return 1;
+   }
+   y = 1;
+   for(;;)
+   {
+      char ch;
+
+      x = 1;
+      for(;;)
+      {
+         ch = fgetc(in_file);
+         if(ch == '\n' || ch == EOF) break;
+         world[x++][y] = ch;
+      }
+      if(ch == EOF) break;
+      y++;
+   }
+   fclose(in_file);
+   if(world[1][1] == ' ')
+   {
+      fprintf(stderr, "Starting point for program is empty.\n");
+      return 1;
+   }
+   current_thread = malloc(sizeof(*current_thread));
+   current_thread->id = threads++;
+   current_thread->x = current_thread->y = 1;
+   current_thread->dx = current_thread->dy = 1;
+   current_thread->stack_head = NULL;
+   current_thread->next = current_thread->prev = current_thread;
+   srandom(time(NULL));
+   for(;;)
+   {
+      int closest_right = 4, closest_left = 4;
+      int which, x, y;
+
+      if(debug) fprintf(stderr, "Thread %3d at (%3d,%3d) ", current_thread->id, current_thread->x, current_thread->y);
+      if(can_turn(1)) closest_left = 1; else if(can_turn(2)) closest_left = 2; else if(can_turn(3)) closest_left = 3;
+      if(can_turn(-1)) closest_right = 1; else if(can_turn(-2)) closest_right = 2; else if(can_turn(-3)) closest_right = 3;
+      if(can_turn(0))
+      {
+         if(debug) fprintf(stderr, "is happily marching along (0 degrees).\n");
+      }
+      else if(closest_left == closest_right)
+      {
+         switch(closest_left)
+         {
+         case 1: if(debug) fprintf(stderr, "faces a difficult choice (45 or 315 degrees).\n");
+                 if(random() & 1024) turn(1); else turn(-1);
+                 break;
+         case 2: if(debug) fprintf(stderr, "spawns a new thread (90 and 270 degrees).\n");
+                 turn(2);
+                 new_thread();
+                 current_thread = current_thread->next;
+                 continue;
+         case 3: if(debug) fprintf(stderr, "is confused (135 and 225 degrees).\n");
+                 fprintf(stderr, "The programmer has not yet decided what a 135/225 T-junction should do!");
+                 return 1;
+         case 4: if(debug) fprintf(stderr, "bumps into a dead end (180 degrees).\n");
+                 kill_thread();
+                 continue;
+         }
+      }
+      else if(closest_left < closest_right)
+      {
+         switch(closest_left)
+         {
+         case 1: if(debug) fprintf(stderr, "places a one on his stack (45 degrees).\n");
+                 push(1);
+                 break;
+         case 2: which = pop();
+                 if(which)
+                 {
+                    if(debug) fprintf(stderr, "is afraid from the turn (90 degrees).\n");
+                    turn(2);
+                    break;
+                 }
+                 if(debug) fprintf(stderr, "happily marches through the turn (90 degrees).\n");
+                 break;
+         case 3: which = pop();
+                 y = pop();
+                 x = pop();
+                 if(which)
+                 {
+                    if(debug) fprintf(stderr, "gets a number for his stack (135 degrees).\n");
+                    push(world[x][y]);
+                 }
+                 else
+                 {
+                    if(debug) fprintf(stderr, "puts a number in his stack down (135 degrees).\n");
+                    world[x][y] = pop();
+                 }
+                 break;
+         }
+         if(debug) print_stack();
+         turn(closest_left);
+      }
+      else
+      {
+         switch(closest_right)
+         {
+         case 1: if(debug) fprintf(stderr, "sits down to work out a subtraction (315 degrees).\n");
+                 y = pop();
+                 x = pop();
+                 push(x - y);
+                 break;
+         case 2: which = pop();
+                 if(which)
+                 {
+                    if(debug) fprintf(stderr, "is afraid from the turn (270 degrees).\n");
+                    turn(-2);
+                    break;
+                 }
+                 if(debug) fprintf(stderr, "happily marches through the turn (270 degrees).\n");
+                 break;
+         case 3: which = pop();
+                 if(which)
+                 {
+                    which = pop();
+                    if(debug) fprintf(stderr, "wishes you to know that \"%c\" (225 degrees).\n", which);
+                    if(!debug || !isatty(1)) putchar(which);
+                 }
+                 else
+                 {
+                    which = getchar();
+                    if(debug) fprintf(stderr, "discovers that \"%c\" (225 degrees).\n", which);
+                    push(which);
+                 }
+                 break;
+         }
+         if(debug) print_stack();
+         turn(-closest_right);
+      }
+      current_thread->x += current_thread->dx;
+      current_thread->y += current_thread->dy;
+      current_thread = current_thread->next;
+   }
+}
+
+/*
+ *   Wierd Interpreter:
+ *
+ *	Wierd Language developed by Chris Pressey, August 1997
+ *	Interpreter written 05 August 1997 by John Colagioia
+ *
+ *	Deviations from the "Official" Wierd:
+ *		Direction:  The IP will always try to continue in the same
+ *			direction (or as close as possible).  When two
+ *			equally-likely possibilities exist, it will choose
+ *			the "leftmost" branch.
+ *		Conditionals:  When the IP connects to a 90-degree angle,
+ *			it pops the stack.  If the result is zero, it
+ *			continues as if nothing interesting happens.  If
+ *			nonzero, it reverses the IP direction.
+ *		Gap-Sparking:  If the IP has just "sparked into" a
+ *			location which is isolated, the program is
+ *			considered erroneous, as the IP direction is
+ *			undefined at that time.
+ *
+ *	Revision History:
+ *	   R#:   Date:	    Inits:   Reason:
+ *	    0    05aug97    jnc	     Origination
+ *	    1    06aug97    jnc	     Various Bugfixes, Revised Conditionals
+ *	    2    07aug97    jnc	     Added Multithreading, Revised Conditionals
+ *	    3    08aug97    jnc	     Added "Gap-Sparking"
+ *	    4    08aug97    jnc	     General Cleanup and Bugfixes
+ *
+ *	To Do:
+ *	    --	Heavier testing (requires writing Wierd code...).
+ *	    --	Add a tty or graphical display routine.
+ *
+ */
+
+/*** Preprocessor Directives ***/
+	/* Included header files */
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+	/* Constants and Macros */
+#define	SIZE	128
+
+/*** Data Structures ***/
+struct	iplist	/* An instruction pointer */
+	{
+	 int	ipid;		/* A unique identifier */
+	 int	x;		/* The current ordinate value */
+	 int	y;		/* The current abscissa value */
+	 int	dx;		/* The next change in x to be applied */
+	 int	dy;		/* The next change in y to be applied */
+	 int	stack[SIZE];	/* A stack exclusive to this IP */
+	 int	s_top;		/* A pointer to the stack top */
+	 struct	iplist	*next;	/* The next IP available */
+	};
+
+/*** Function Prototypes (only for the function table below) ***/
+int	nop		(struct iplist **);
+int	push1		(struct iplist **);
+int	subtract	(struct iplist **);
+int	condition	(struct iplist **);
+int	getput		(struct iplist **);
+int	inputoutput	(struct iplist **);
+int	terminus	(struct iplist **);
+
+/*** more prototypes, because my compiler likes them - cap */
+int turn45 (int * xdir, int * ydir);
+int getnextturn (int x, int y, int * dx, int * dy);
+
+/*** Global Variables ***/
+char	workspace[SIZE][SIZE];	/* The "Wierd memory space" */
+int	tmpx, tmpy,		/* temporary deltas */
+	ipid = 0, ip_killed;	/* IP identifier, kill flag */
+struct	iplist	*list;		/* The list of IPs */
+int	(*function[])(struct iplist **) =
+		{		/* Function table */
+		 nop,			/* 0 degrees */
+		 push1,			/* 45 degrees */
+		 condition,		/* 90 degrees */
+		 getput,		/* 135 degrees */
+		 terminus,		/* 180 degrees */
+		 inputoutput,		/* 225 degrees */
+		 condition,		/* 270 degrees */
+		 subtract		/* 315 degrees */
+		};
+
+/*** Source code for Interpreter Functions ***/
+
+/* Function main():
+ *	Initializes data structures and environment, and iterates through
+ *	each IP until termination.  Also handles most common errors.
+ */
+int main (int argc, char *argv[])
+{
+ int	i, x, y;	/* Temporary variables */
+ FILE	*infile;	/* Input file */
+
+ if (argc < 2)		/* Not enough arguments--don't know what to do */
+	{
+	 fprintf (stderr, "Error:\n\t%s <Wierd Filename>\n", argv[0]);
+	 exit (1);
+	}
+ infile = fopen (argv[1], "r");
+ if (infile == NULL)		/* Bad input filename given */
+	{
+	 fprintf (stderr, "Error:  Invalid Wierd filename: \"%s\".\n",
+		argv[1]);
+	 exit (2);
+	}
+
+ for (x=0;x<SIZE;++x)		/* Clear the memoryspace */
+	for (y=0;y<SIZE;++y)
+		workspace[x][y] = '\000';
+
+ y = 1;				/* Read the file into the memoryspace */
+ while (!feof (infile))
+	{
+	 fscanf (infile, "%[^\n]", &workspace[y][1]);
+	 fgetc (infile);
+	#ifdef DEBUG
+	 printf ("%s\n", &workspace[y][1]);
+	#endif
+	 ++y;
+	}
+ fclose (infile);		/* Clean up file handles */
+ for (x=0;x<SIZE;++x)		/* Convert nulls to spaces */
+	for (y=0;y<SIZE;++y)
+		if (workspace[x][y] == '\000')
+			workspace[x][y] = ' ';
+
+				/* Initialize the first IP */
+ list = (struct iplist *) malloc (sizeof (struct iplist));
+ list->x = list->y = list->dx = list->dy = 1;
+ list->s_top = 0;
+ list->next = list;
+ list->ipid = ++ipid;
+
+			/* Loop as long as the location is valid */
+ while (workspace[list->x][list->y] != ' ')
+	{
+	 ip_killed = 0;		/* Initialize the kill-flag */
+	#ifdef DEBUG
+	 printf ("<%d>\t", list->ipid);
+	 printf ("(%d,%d)\t", list->y, list->x);
+	 for (i=0;i<list->s_top;++i)
+		printf ("[%d] ", list->stack[i]);
+	#endif
+	 tmpx = list->dx;	/* Save the current direction */
+	 tmpy = list->dy;		/* and change it */
+	 i = getnextturn (list->x, list->y, &tmpx, &tmpy);
+	#ifdef DEBUG
+	 printf ("\t\t%d\n", i);
+	#endif
+	 if (i % 45)		/* Invalid direction! */
+		printf ("\007ERROR!!\007\n");
+	 else	{		/* Call the appropriate function */
+		 i = function[i/45](&list);
+		 if (i == -1)		/* Out of IPs */
+			{
+			 free (list);
+			 return 0;
+			}
+		}
+	 if (!ip_killed)	/* Only update if it's the same IP */
+		{
+		 list->x += list->dx = tmpx;	/* Update location */
+		 list->y += list->dy = tmpy;
+		 list = list->next;		/* Next IP */
+		}
+	}
+#ifdef DEBUG
+ printf ("Program ungracefully terminated!\n");
+#endif
+ return 0;
+}
+
+/* Function checkdir():
+ *	Simple function to determine validity of location a given delta
+ *	from the given location.
+ */
+int checkdir (int x, int y, int dx, int dy)
+{
+ return (workspace[x+dx][y+dy] != ' ');	/* Only space is invalid */
+}
+
+/* Function rotate():
+ *	Turns an IP the specified number of degrees (though only in 45-
+ *	degree increments).
+ */
+int rotate (int * xdir, int * ydir, int turn)
+{
+ int	i;
+
+ for (i=0;i<turn;i+=45)		/* We only work in 45-degree increments */
+	turn45 (xdir, ydir);
+ return 0;
+}
+
+/* Function turn45():
+ *	Rotates a dx,dy heading 45 degrees clockwise.  Very unclean
+ *	implementation, but it works for now.  Once we expand beyond two
+ *	dimensions, though, this will have to be heavily rewritten.
+ */
+int turn45 (int * xdir, int * ydir)
+{
+ if (*ydir == 1 && *xdir == -1 || *ydir == -1 && *xdir == 1)
+	*ydir = 0;
+ else if (*xdir == 1 && *ydir == 1 || *xdir == -1 && *ydir == -1)
+	*xdir = 0;
+ else if (*ydir)
+	*xdir -= *ydir;
+ else	*ydir += *xdir;
+ return 0;
+}
+
+/* Function getnextturn():
+ *	Checks the 7 of the 8 valid directions from the given point,
+ *	choosing those 7 based on the IP delta.  Returns the "leftmost"
+ *	direction closest to "straight" that is available from the given
+ *	location.
+ */
+int getnextturn (int x, int y, int * dx, int * dy)
+{
+ if (checkdir (x, y, *dx, *dy))
+	return 0;
+ rotate (dx, dy, 45);
+ if (checkdir (x, y, *dx, *dy))
+	return 45;
+ rotate (dx, dy, 270);
+ if (checkdir (x, y, *dx, *dy))
+	return 315;
+ rotate (dx, dy, 135);
+ if (checkdir (x, y, *dx, *dy))
+	return 90;
+ rotate (dx, dy, 180);
+ if (checkdir (x, y, *dx, *dy))
+	return 270;
+ rotate (dx, dy, 225);
+ if (checkdir (x, y, *dx, *dy))
+	return 135;
+ rotate (dx, dy, 90);
+ if (checkdir (x, y, *dx, *dy))
+	return 225;
+ return 180;
+}
+
+/* Function add_thread():
+ *	Inserts a node on the circular linked list of IPs, and initializes
+ *	the node as a new IP.
+ */
+int add_thread (struct iplist * ip, int dx, int dy)
+{
+ struct iplist	*temp;
+ int		 i;
+
+				/* Create new node on list */
+ temp = (struct iplist *) malloc (sizeof (struct iplist));
+ temp->ipid = ++ipid;		/* Give an identifier */
+ temp->next = ip->next;		/* Insert into list */
+ temp->x = ip->x - dx;		/* Initialize based on current IP */
+ temp->y = ip->y - dy;
+ temp->dx = - dx;
+ temp->dy = - dy;
+ temp->s_top = ip->s_top;
+ for (i=0;i<ip->s_top;++i)
+	temp->stack[i] = ip->stack[i];
+ ip->next = temp;
+#ifdef DEBUG
+ printf ("Thread #%d created.\n", temp->ipid);
+#endif
+ return 0;
+}
+
+/* Function kill_thread():
+ *	Removes the current node from the circular linked list of IPs.
+ */
+int kill_thread (struct iplist ** ip)
+{
+ struct	iplist	*temp;
+#ifdef DEBUG
+ int	id;
+
+ id = (*ip)->ipid;
+#endif
+ temp = *ip;
+ while (temp->next != *ip)	/* Get IP before this one */
+	temp = temp->next;
+ temp->next = (*ip)->next;	/* Point around the current IP */
+ free (*ip);			/* Deallocate the IP */
+ *ip = temp;			/* Return the previous one */
+#ifdef DEBUG
+ printf ("Thread #%d destroyed, passing to #%d.\n", id, (*ip)->ipid);
+#endif
+ return 0;
+}
+
+/* Function find_far():
+ *	Called when the IP has no obvious place to go.  Checks the region
+ *	around (7x7 locations) the current IP location for a "closest
+ *	point" based on the current location as well as the current IP
+ *	direction.
+ */
+int find_far (int x, int y, int dx, int dy, int **xcoors, int **ycoors)
+{
+ int	i, j, pts, xs[40], ys[40], ti, tj,
+	a[] = {2, 3, -2, -3, 0, 1, -1};		/* Order of precedence */
+
+ pts = 0;
+ for (i=0;i<7;++i) for (j=0;j<7;++j)
+	/* Scan along the array in two dimensions */
+	if (i < 4 || j < 4)	/* If at least one index looks at {2,3} */
+		{
+		 ti = dx>0?a[i]:-a[i];	/* Invert if a delta is */
+		 tj = dy>0?a[j]:-a[j];		/* negative */
+		 if (x>a[i] && y>a[j] &&
+			workspace[x+ti][y+tj] != ' ')
+			{	/* If the location exists and isn't */
+			 xs[pts] = x + ti;	/* a space */
+			 ys[pts] = y + tj;	/* Add to list */
+			 if (xs[pts] > 0 && ys[pts] > 0)
+				++ pts;
+			}
+		}
+ *xcoors = (int *) malloc (sizeof (int) * pts);
+ *ycoors = (int *) malloc (sizeof (int) * pts);
+ for (i=0;i<pts;++i)	/* Copy the list of candidates to where the */
+	{			/* calling function suggests */
+	 (*xcoors)[i] = xs[i];
+	 (*ycoors)[i] = ys[i];
+	}
+ return (pts);		/* Return the number of points found */
+}
+
+/*** Source Code for internal Interpreter Operations (called from the
+     function table only ***/
+
+/* Function nop():
+ *	No-operation.
+ */
+int nop (struct iplist ** list)
+{
+ return 0;			/* Self-explanatory */
+}
+
+/* Function push1():
+ *	Pushes a constant value 1 onto the IP's stack.
+ */
+int push1 (struct iplist ** ip)
+{
+ struct	iplist	*list = *ip;
+
+ list->stack[list->s_top++] = 1;	/* Self-explanatory */
+ return 0;
+}
+
+/* Function condition():
+ *	If the top of the IP's stack is zero, functions as nop().
+ *	Otherwise, it reverses the direction of the IP.
+ */
+int condition (struct iplist ** ip)
+{
+ int	i;
+ struct	iplist	*list = *ip;
+
+		/* Two coincident 90-degree turns spawns a new IP */
+ if (workspace[list->x-tmpx][list->y-tmpy] != ' ')
+	add_thread (list, tmpx, tmpy);
+		/* Otherwise, check top of the stack determines whether */
+			/* we continue or change direction */
+ else if (list->s_top && list->stack[--list->s_top])
+	{
+	 list->x += tmpx;
+	 list->y += tmpy;
+	 i = tmpx;	/* Reflect the IP */
+	 tmpx = -tmpy;
+	 tmpy = -i;
+	 i = getnextturn (list->x, list->y, &tmpx, &tmpy);
+	#ifdef DEBUG
+	 printf ("<%d>\t", list->ipid);
+	 printf ("(%d,%d)\t", list->y, list->x);
+	 for (i=0;i<list->s_top;++i)
+		printf ("[%d] ", list->stack[i]);
+	 printf ("\t\t%d\n", i);
+	#endif
+	}
+ *ip = list;	/* Fix the IP list in case the current thread changed */
+ return 0;
+}
+