From d60ef9b732a969376f40b89ae8cf2c3159121758 Mon Sep 17 00:00:00 2001
From: davidly <davidly_lee@hotmail.com>
Date: Fri, 5 Jul 2024 08:30:14 -0700
Subject: [PATCH] Microsoft muLISP-86 v5.10

---
 Microsoft muLISP-86 v51/ANIMAL.LSP   |  207 +++
 Microsoft muLISP-86 v51/ANIMAL.MEM   |  205 +++
 Microsoft muLISP-86 v51/COMMON.LSP   |  912 ++++++++++++++
 Microsoft muLISP-86 v51/COMTOEXE.COM |  Bin 0 -> 1564 bytes
 Microsoft muLISP-86 v51/DEBUG.LSP    |  244 ++++
 Microsoft muLISP-86 v51/DOCTOR.LSP   |  956 ++++++++++++++
 Microsoft muLISP-86 v51/E.LSP        |   48 +
 Microsoft muLISP-86 v51/EDIT.LSP     | 1733 ++++++++++++++++++++++++++
 Microsoft muLISP-86 v51/EIGHTS.LSP   |  261 ++++
 Microsoft muLISP-86 v51/GRAPHICS.LSP |  220 ++++
 Microsoft muLISP-86 v51/HANOI.LSP    |  145 +++
 Microsoft muLISP-86 v51/HELP.LSP     |  484 +++++++
 Microsoft muLISP-86 v51/INTERLIS.LSP |  714 +++++++++++
 Microsoft muLISP-86 v51/LESSONS.LSP  |  195 +++
 Microsoft muLISP-86 v51/METAMIND.LSP |  276 ++++
 Microsoft muLISP-86 v51/MOUSE.LSP    |   59 +
 Microsoft muLISP-86 v51/MULISP.COM   |  Bin 0 -> 38729 bytes
 Microsoft muLISP-86 v51/MULISP1.LES  |  341 +++++
 Microsoft muLISP-86 v51/MULISP2.LES  |  518 ++++++++
 Microsoft muLISP-86 v51/MULISP3.LES  |  518 ++++++++
 Microsoft muLISP-86 v51/MULISP4.LES  |  459 +++++++
 Microsoft muLISP-86 v51/MULISP5.LES  |  391 ++++++
 Microsoft muLISP-86 v51/MULISP6.LES  |  620 +++++++++
 Microsoft muLISP-86 v51/MULISP83.LSP |  128 ++
 Microsoft muLISP-86 v51/README       |   46 +
 Microsoft muLISP-86 v51/SIEVE.LSP    |   49 +
 Microsoft muLISP-86 v51/STATE.SYS    |  Bin 0 -> 33278 bytes
 Microsoft muLISP-86 v51/STRUCTUR.LSP |  583 +++++++++
 Microsoft muLISP-86 v51/TTT.LSP      |  212 ++++
 Microsoft muLISP-86 v51/m.bat        |    5 +
 30 files changed, 10529 insertions(+)
 create mode 100644 Microsoft muLISP-86 v51/ANIMAL.LSP
 create mode 100644 Microsoft muLISP-86 v51/ANIMAL.MEM
 create mode 100644 Microsoft muLISP-86 v51/COMMON.LSP
 create mode 100644 Microsoft muLISP-86 v51/COMTOEXE.COM
 create mode 100644 Microsoft muLISP-86 v51/DEBUG.LSP
 create mode 100644 Microsoft muLISP-86 v51/DOCTOR.LSP
 create mode 100644 Microsoft muLISP-86 v51/E.LSP
 create mode 100644 Microsoft muLISP-86 v51/EDIT.LSP
 create mode 100644 Microsoft muLISP-86 v51/EIGHTS.LSP
 create mode 100644 Microsoft muLISP-86 v51/GRAPHICS.LSP
 create mode 100644 Microsoft muLISP-86 v51/HANOI.LSP
 create mode 100644 Microsoft muLISP-86 v51/HELP.LSP
 create mode 100644 Microsoft muLISP-86 v51/INTERLIS.LSP
 create mode 100644 Microsoft muLISP-86 v51/LESSONS.LSP
 create mode 100644 Microsoft muLISP-86 v51/METAMIND.LSP
 create mode 100644 Microsoft muLISP-86 v51/MOUSE.LSP
 create mode 100644 Microsoft muLISP-86 v51/MULISP.COM
 create mode 100644 Microsoft muLISP-86 v51/MULISP1.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP2.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP3.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP4.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP5.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP6.LES
 create mode 100644 Microsoft muLISP-86 v51/MULISP83.LSP
 create mode 100644 Microsoft muLISP-86 v51/README
 create mode 100644 Microsoft muLISP-86 v51/SIEVE.LSP
 create mode 100644 Microsoft muLISP-86 v51/STATE.SYS
 create mode 100644 Microsoft muLISP-86 v51/STRUCTUR.LSP
 create mode 100644 Microsoft muLISP-86 v51/TTT.LSP
 create mode 100644 Microsoft muLISP-86 v51/m.bat

diff --git a/Microsoft muLISP-86 v51/ANIMAL.LSP b/Microsoft muLISP-86 v51/ANIMAL.LSP
new file mode 100644
index 0000000..855969f
--- /dev/null
+++ b/Microsoft muLISP-86 v51/ANIMAL.LSP	
@@ -0,0 +1,207 @@
+;File:  ANIMAL.LSP  (C)		12/29/85	Soft Warehouse, Inc.
+
+
+(LOOP (PRIN1 '*) (EVAL (READ)) ((NULL RDS)) )
+
+
+(DEFUN ANIMAL (
+    *BASE* *NAME* *DIRTY* )
+  (CLEAR-SCREEN)
+  (TERPRI 2)
+  (CENTER "* * *   T H E   A N I M A L   G A M E   * * *")
+  (TERPRI 3)
+  (PRINTC "Hello, I would like to play the animal guessing game with you.")
+  (TERPRI)
+  (PRINTC "Please type in your first name and press the RETURN key so we")
+  (PRINC "can chat on a more friendly basis:  ")
+  (CLEAR-INPUT)
+  (SETQ *NAME* (STRING-CAPITALIZE (READ-LINE)))
+  (TERPRI)
+  (PRINTC "Thanks " *NAME* ", now think of an animal and I will try to guess")
+  (PRINTC "what it is by asking you some yes-or-no questions.")
+  (TERPRI)
+  (SETQ *BASE* *INIT-BASE*)
+  ( ((OR
+	(AND (RDS (PACK* *NAME* '.MEM))
+	  (PRINTC "Would you like to refresh my memory about animals from")
+	  (Y-OR-N-P "our previous session?") )
+	(AND (RDS 'ANIMAL.MEM)
+	  (PRINTC "Would you like to refresh my memory about animals from")
+	  (Y-OR-N-P "the pre-built animal data file?") ) )
+      (SETQ *BASE* (MAKE-BASE (READ))) ) )
+  (RDS)
+  (LOOP
+    (TERPRI)
+    (PRINC "After you think of an animal, press any key to start the game. ")
+    (READ-KEY)
+    (TERPRI 2)
+    (PLAY-ROUND *BASE*)
+    ((NOT (Y-OR-N-P "Would you like to play another round?")))
+    (CLEAR-SCREEN) )
+  (TERPRI)
+  ( ((NOT *DIRTY*))
+    (PRINTC *NAME* ", do you want me to save all you have taught me")
+    ((Y-OR-N-P "so I will remember it next time we play Animal?")
+      (WRS (PACK* *NAME* '.MEM))
+      (PRT-BASE *BASE* 0)
+      (TERPRI)
+      (WRS)
+      (SETQ *DIRTY*)
+      (TERPRI) )
+    (TERPRI) )
+  (PRINTC "I hope you enjoyed playing the Animal Game " *NAME* ".")
+  (PRINC "Let's get together again some time!")
+  (TERPRI 2) )
+
+
+(DEFUN PLAY-ROUND (BASE
+    ANIMAL ANSWERS NEW-BASE QUESTION)
+  (LOOP
+    ((ATOM (CDR BASE))
+      ((Y-OR-N-P (PACK* "I bet it's " (@ (CAR BASE)) "?"))
+	(PRINTC "Yea, I got it!  Thanks for the game " *NAME* ".")
+	(TERPRI) )
+      (PRINC "I give up, what animal were you thinking of?  ")
+      (SETQ ANIMAL (STRING-UPCASE (READ-LINE)))
+      (TERPRI)
+      ((EQ ANIMAL (CAR BASE))
+	(PRINTC "Stop fooling around " *NAME* ", that is what I just guessed!")
+	(TERPRI) )
+      (SETQ NEW-BASE (ALREADY-EXISTS ANIMAL (REVERSE ANSWERS) *BASE*))
+      ( ((NOT NEW-BASE))
+	(PRINTC "I think you may have incorrectly answered the question")
+	(TERPRI)
+	(SPACES 10)
+	(PRINTC """" (CAR NEW-BASE) "?""")
+	(TERPRI)
+	((Y-OR-N-P (PACK* *NAME*
+		" are you sure you answered this question correctly?"))
+	  (REMOVE-ANIMAL ANIMAL *BASE*)
+	  (PRINTC "OK, I fixed by memory so I won't make that mistake again.")
+	  (TERPRI) )
+	(TERPRI)
+	(RETURN) )
+      (PRINTC "What question can I ask for which a YES answer indicates")
+      (PRINTC (@ ANIMAL) " rather than " (@ (CAR BASE)) "?")
+      (SETQ QUESTION (STRING-RIGHT-TRIM "?.! " (READ-LINE)))
+      (TERPRI)
+      (DISPLACE BASE (LIST QUESTION (LIST (CAR BASE)) (LIST ANIMAL)))
+      (PRINTC "Thanks for telling me that.  I'll be sure to remember it.")
+      (SETQ *DIRTY* T) )
+    (PUSH (Y-OR-N-P (PACK* (CAR BASE) "?")) ANSWERS)
+    (TERPRI)
+    ( ((CAR ANSWERS)
+	(SETQ BASE (CADDR BASE)) )
+      (SETQ BASE (CADR BASE)) ) ) )
+
+(DEFUN ALREADY-EXISTS (ANIMAL ANSWERS BASE)
+  ((ATOM (CDR BASE)) NIL)
+  ((CAR ANSWERS)
+    ((MEMBER-BASE ANIMAL (CADR BASE)) BASE)
+    (ALREADY-EXISTS ANIMAL (CDR ANSWERS) (CADDR BASE)) )
+  ((MEMBER-BASE ANIMAL (CADDR BASE)) BASE)
+  (ALREADY-EXISTS ANIMAL (CDR ANSWERS) (CADR BASE)) )
+
+(DEFUN REMOVE-ANIMAL (ANIMAL BASE)
+  ((MEMBER-BASE ANIMAL (CADR BASE))
+    (SETQ SUB-BASE (CADR BASE))
+    ((EQ ANIMAL (CAR (CADR SUB-BASE)))
+      (RPLACA (CDR BASE) (CADDR SUB-BASE)) )
+    ((EQ ANIMAL (CAR (CADDR SUB-BASE)))
+      (RPLACA (CDR BASE) (CADR SUB-BASE)) )
+    (REMOVE-ANIMAL ANIMAL (CADR BASE)) )
+  (SETQ SUB-BASE (CADDR BASE))
+  ((EQ ANIMAL (CAR (CADR SUB-BASE)))
+    (RPLACA (CDDR BASE) (CADDR SUB-BASE)) )
+  ((EQ ANIMAL (CAR (CADDR SUB-BASE)))
+    (RPLACA (CDDR BASE) (CADR SUB-BASE)) )
+  (REMOVE-ANIMAL ANIMAL (CADDR BASE)) )
+
+(DEFUN MEMBER-BASE (ANIMAL BASE)
+  (LOOP
+    ((ATOM (CDR BASE))
+      (EQ (CAR BASE) ANIMAL) )
+    ((MEMBER-BASE ANIMAL (CADR BASE)))
+    (SETQ BASE (CADDR BASE)) ) )
+
+(DEFUN MAKE-BASE (BASE)
+  ((ATOM BASE)
+    (LIST BASE) )
+  (LIST (CAR BASE) (MAKE-BASE (CADR BASE)) (MAKE-BASE (CADDR BASE))) )
+
+(DEFUN PRT-BASE (BASE TAB PRIN1)
+  (SPACES TAB)
+  ((ATOM (CDR BASE))
+    (PRIN1 (CAR BASE)) )
+  (PRINC '"(")
+  (PRINT (CAR BASE))
+  (PRT-BASE (CADR BASE) (+ TAB 2))
+  (TERPRI)
+  (PRT-BASE (CADDR BASE) (+ TAB 2))
+  (PRINC '")") )
+
+(SETQ *INIT-BASE*
+ '("Does it hava a backbone"
+    ("Can it fly"
+	(WORM)
+	(MOSQUITO))
+    ("Is it a warm blooded animal"
+	("Does it have gills and live all its life in water"
+	    ("Does it start life with gills and then become an air breather"
+		("Does it have legs"
+		    (SNAKE)
+		    (CROCODILE))
+		(FROG))
+	    ("TUNA FISH"))
+	("Does it nurse its young with milk"
+	    ("Can it fly"
+		(CHICKEN)
+		(ROBIN))
+	    ("Does it live in water"
+		("Is it a commonly domesticated animal"
+		    (TIGER)
+		    (DOG))
+		(DOLPHIN)) ))) )
+
+
+(DEFUN DISPLACE (LST1 LST2)
+  (RPLACA LST1 (CAR LST2))
+  (RPLACD LST1 (CDR LST2)) )
+
+(DEFUN @ (NOUN)
+  ((FINDSTRING (CHAR NOUN 0) "AEIOUaeiou")
+    (PACK* "an " NOUN) )
+  (PACK* "a " NOUN) )
+
+(DEFUN Y-OR-N-P (MSG
+    CHAR READ-CHAR RDS WRS )
+  ( ((NULL MSG))
+    (FRESH-LINE)
+    (WRITE-STRING (PACK* MSG " (Y/N) ")) )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    ((EQ CHAR 'Y)
+      (WRITE-LINE CHAR)
+      T )
+    ((EQ CHAR 'N)
+      (WRITE-LINE CHAR)
+      NIL )
+    (WRITE-BYTE 7) ) )
+
+(DEFUN READ-KEY (
+    READ-CHAR RDS)
+  (READ-CHAR) )
+
+(DEFUN PRINTC LST
+  (PRINC (PACK LST))
+  (TERPRI)
+  'T )
+
+(DEFUN CENTER (MSG)
+  (SET-CURSOR (ROW)
+	(TRUNCATE (- (CADDDR (MAKE-WINDOW)) (LENGTH MSG)) 2))
+  (WRITE-LINE MSG) )
+
+(ANIMAL (RDS))
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/ANIMAL.MEM b/Microsoft muLISP-86 v51/ANIMAL.MEM
new file mode 100644
index 0000000..7fce105
--- /dev/null
+++ b/Microsoft muLISP-86 v51/ANIMAL.MEM	
@@ -0,0 +1,205 @@
+;File:	ANIMAL.MEM		08/27/85	Animal game data base
+
+
+("Does it nurse its young with milk"
+ ("Does it have legs"
+  ("Does it have a shell"
+   ("Does it have suckers on its arms"
+    ("Is it boneless"
+     ("Does it swim"
+      SNAKE
+      ("Is it a ferocious meat eating fish"
+       ("Is it a type of salmon"
+	("Can you wear it on your leg"
+	 GUPPY
+	 "GARTER SNAKE")
+	CHINOOK)
+       PIRANHA) )
+     "SEA CUCUMBER")
+    OCTOPUS)
+   ("Does it live in water"
+    SNAIL
+    CLAM) )
+  ("Does it have a beak"
+   ("Is it soft and squishy"
+    ("Does it go through metamorphosis"
+     ("Does it breathe fire"
+      ("Does it live in a colony"
+       ("Does it have claws"
+	("Does it suck blood"
+	 ("Is it an insect"
+	  ("Does it live in a cavern"
+	   ("Does it have horns"
+	    GECKO
+	    RAM)
+	   WUMPUS)
+	  ("Does it annoy housewives"
+	   ("Does it fly"
+	    GRASSHOPPER
+	    BUTTERFLY)
+	   COCKROACH) )
+	 ("Does a clock do it too"
+	  FLEA
+	  TIC) )
+	("Does it walk sideways"
+	 LOBSTER
+	 CRAB) )
+       ANT)
+      DRAGON)
+     ("Does it live in a hive"
+      ("Is it an insect"
+       FROG
+       ("Does it suck blood"
+	("Does it live in a nest"
+	 FLY
+	 WASP)
+	MOSQUITO) )
+      BEE) )
+    ("Do ants farm them"
+     ("Is it a reptile"
+      ("Does it have eight legs"
+       ("Does it have wings"
+	CATERPILLAR
+	COCKROACH)
+       SPIDER)
+      ("Does it eat mice"
+       SKINK
+       "MONITOR LIZARD") )
+     APHID) )
+   ("Does the male have a pretty tail"
+    ("Does it fly"
+     ("Does it have eight arms"
+      ("Is it the largest flightless bird"
+       MYNAH
+       ("Is it extinct"
+	OSTRICH
+	"DODO BIRD") )
+      OCTOPUS)
+     ("Does it have webbed feet for swimming"
+      ("Is it a scavenger"
+       ("Does it coo"
+	("Does it have long legs"
+	 KIWI
+	 HERON)
+	DOVE)
+       VULTURE)
+      ("Is it a large stately swimming bird with a curved neck"
+       ("Does it honk"
+	DUCK
+	GOOSE)
+       SWAN) ) )
+    ("Does the male have a comb"
+     ("Does it sometimes talk"
+      PEACOCK
+      PARROT)
+     CHICKEN) ) ) )
+ ("Does it have a long neck"
+  ("Does it live in trees"
+   ("Does it oink"
+    ("Is it wild"
+     ("Does it have claws"
+      ("Does it talk"
+       COW
+       HUMAN)
+      ("Does it bark"
+       CAT
+       DOG) )
+     ("Is it a member of the cat family"
+      ("Does it hibernate"
+       ("Would Lloyd Bridges be scared of it"
+	("Does it have a trunk"
+	 ("Does it have antlers"
+	  ("Does it hop"
+	   ("Does it have a bill"
+	    ("Does it have stripes"
+	     ("Does it abandon sinking ships"
+	      ("Does it like cheese"
+	       ("Do they sometimes walk off cliffs en masse"
+		("Is it the largest of the apes"
+		 ("Does the male have a face marked in blue and scarlet"
+		  ("Is it a fabulous animal with a single long horn"
+		   ("Does it have a mask"
+		    ("Is one named RIKI TIKI TAVI"
+		     ("Is it a weasel"
+		      ("Does it live in the water"
+		       WOLF
+		       ("Can it walk on land"
+			WHALE
+			HIPPO) )
+		      WEASEL)
+		     MONGOOSE)
+		    RACCOON)
+		   UNICORN)
+		  MANDRILL)
+		 GORILLA)
+		LEMMING)
+	       MOUSE)
+	      RAT)
+	     ZEBRA)
+	    PLATYPUS)
+	   KANGAROO)
+	  ("Is it a large handsome African antelope"
+	   MOOSE
+	   KUDU) )
+	 ("Is it hairy and extinct"
+	  ELEPHANT
+	  "WOOLY MAMMOTH") )
+	("Does it repel enemies with smell"
+	 ("Does it breathe air"
+	  SHARK
+	  ("Does it have an airhole on its head"
+	   ("Can it be mistaken for a mermaid"
+	    ("Does it live in the Himalayas"
+	     HIPPOPOTAMUS
+	     "ABOMINABLE SNOWMAN")
+	    MANATEE)
+	   PORPOISE) )
+	 SKUNK) )
+       ("Is it covered with spines"
+	("Does it live underground and eat twice its weight every day"
+	 ("Does it emerge from hibernation to see his shadow"
+	  BEAR
+	  GROUNDHOG)
+	 SHREW)
+	PORCUPINE) )
+      ("Does it have spots"
+       ("Does it have stripes"
+	("Do its ears have tufts"
+	 LION
+	 LYNX)
+	TIGER)
+       ("Is it the fastest running animal"
+	LEOPARD
+	CHEETAH) ) ) )
+    PIG)
+   ("Does it fly"
+    ("Does it have a long tail"
+     ("Is it a sluggish two or three toed animal that hangs upside down"
+      KOALA
+      SLOTH)
+     ("Is it related to the raccoon"
+      ("Does it feign death when caught"
+       MONKEY
+       OPOSSUM)
+      ("Did Davy Crockett make a hat from its hide"
+       KINKAJOU
+       RACCOON) ) )
+    BAT) )
+  ("Does it have a pouch"
+   ("Do people ride it"
+    ("Does it have stripes"
+     ("Does it swim in the ocean"
+      ("Is it wooly and live in South America"
+       GIRAFFE
+       LLAMA)
+      ("Can it clap"
+       WALRUS
+       SEAL) )
+     ZEBRA)
+    ("Does it have a hump or two"
+     ("Is it usually found in South America"
+      HORSE
+      LLAMA)
+     CAMEL) )
+   KANGAROO) ) )
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/COMMON.LSP b/Microsoft muLISP-86 v51/COMMON.LSP
new file mode 100644
index 0000000..c28289a
--- /dev/null
+++ b/Microsoft muLISP-86 v51/COMMON.LSP	
@@ -0,0 +1,912 @@
+; File: COMMON.LSP		12/29/85	  Soft Warehouse, Inc.
+
+
+; COMMON LISP Library:  This file defines the library functions
+; referred to in Chapter 5 of the muLISP-86 Reference Manual.
+
+
+; Section 5.1:  Selector Functions
+
+(MOVD 'LENGTH 'LIST-LENGTH)
+
+
+; Section 5.2:  Constructor Functions
+
+(MOVD 'REVERSE 'REVAPPEND)
+
+(SETQ *GENSYM-PREFIX* "G")
+(SETQ *GENSYM-COUNT* 0)
+
+(DEFUN GENSYM (ATM)
+; (GENSYM) returns the symbol whose print name consists of *GENSYM-PREFIX*
+; concatenated to *GENSYM-COUNT* and increments *GENSYM-COUNT*.
+; (GENSYM symbol) sets *GENSYM-PREFIX* to <symbol>.
+; (GENSYM integer) sets *GENSYM-COUNT* to <integer>.
+  ( ((NULL ATM))
+    ((SYMBOLP ATM)
+      (SETQ *GENSYM-PREFIX* ATM) )
+    ((AND (INTEGERP ATM) (>= ATM 0))
+      (SETQ *GENSYM-COUNT* ATM) ) )
+  (PROG1 (PACK* *GENSYM-PREFIX* *GENSYM-COUNT*)
+	 (INCQ *GENSYM-COUNT*)) )
+
+
+; Section 5.3:  Modifier Functions
+
+(MOVD 'NREVERSE 'NRECONC)
+(MOVD 'SORT 'STABLE-SORT)
+
+
+; Section 5.4:  Recognizer Functions
+
+(MOVD 'SYMBOLP 'STRINGP)
+(MOVD 'NUMBERP 'RATIONALP)
+
+
+; Section 5.5:  Comparator Functions
+
+(MOVD 'EQUAL 'TREE-EQUAL)
+
+
+; Section 5.7:  Assignment Functions
+
+(DEFMACRO SETF LST
+  ((NULL LST) NIL)
+  ((NULL (CDDR LST))
+    ((ATOM (CAR LST))
+      (CONS 'SETQ LST) )
+    (MAKE-SET-FORM (CAR LST) (CADR LST)) )
+  (CONS 'PROGN (SETF-AUX LST)) )
+
+(DEFUN SETF-AUX (LST)
+  ((NULL LST) NIL)
+  ((ATOM (CAR LST))
+    (CONS (LIST 'SETQ (CAR LST) (CADR LST)) (SETF-AUX (CDDR LST))) )
+  (CONS (MAKE-SET-FORM (CAR LST) (CADR LST)) (SETF-AUX (CDDR LST))) )
+
+(DEFUN MAKE-SET-FORM (PLACE VALUE)
+  ((EQ (CAR PLACE) 'CAR)
+    (LIST 'CAR (LIST 'RPLACA (CADR PLACE) VALUE)) )
+  ((OR (EQ (CAR PLACE) 'CDR) (EQ (CAR PLACE) 'REST))
+    (LIST 'CDR (LIST 'RPLACD (CADR PLACE) VALUE)) )
+  ((EQ (CAR PLACE) 'NTH)
+    (LIST 'CAR (LIST 'RPLACA (CONS 'NTHCDR (CDR PLACE)) VALUE)) )
+  ((EQ (CAR PLACE) 'GET)
+    (LIST 'PUT (CADR PLACE) (CADDR PLACE) VALUE) )
+  ((EQ (CAR PLACE) 'SYMBOL-FUNCTION)
+    (LIST 'PUTD (CADR PLACE) VALUE) )
+  ((GET (CAR PLACE) 'CAR)  (LIST 'CAR
+      (LIST 'RPLACA (LIST (GET (CAR PLACE) 'CAR) (CADR PLACE)) VALUE)) )
+  ((GET (CAR PLACE) 'CDR)  (LIST 'CDR
+      (LIST 'RPLACD (LIST (GET (CAR PLACE) 'CDR) (CADR PLACE)) VALUE)) )
+  ((GET (CAR PLACE) 'NTH)
+    (LIST 'CAR (LIST 'RPLACA
+		     (LIST 'NTHCDR (GET (CAR PLACE) 'NTH) (CADR PLACE))
+		     VALUE)) )
+  ((MACRO-FUNCTION-P (CAR PLACE))
+    (MAKE-SET-FORM (MACROEXPAND PLACE) VALUE) )
+  (BREAK (LIST 'SETF PLACE VALUE) "Invalid Place Form") )
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'CAR (CDR PAIR)))
+  '((CAAR . CAR) (CADR . CDR)
+    (CAAAR . CAAR) (CAADR . CADR) (CADAR . CDAR) (CADDR . CDDR)
+    (CAAAAR . CAAAR) (CAAADR . CAADR) (CAADAR . CADAR) (CAADDR . CADDR)
+    (CADAAR . CDAAR) (CADADR . CDADR) (CADDAR . CDDAR) (CADDDR . CDDDR)) )
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'CDR (CDR PAIR)))
+  '((CDAR . CAR) (CDDR . CDR)
+    (CDAAR . CAAR) (CDADR . CADR) (CDDAR . CDAR) (CDDDR . CDDR)
+    (CDAAAR . CAAAR) (CDAADR . CAADR) (CDADAR . CADAR) (CDADDR . CADDR)
+    (CDDAAR . CDAAR) (CDDADR . CDADR) (CDDDAR . CDDAR) (CDDDDR . CDDDR)) )
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'NTH (CDR PAIR)))
+  '((FIRST . 0) (SECOND . 1) (THIRD . 2) (FOURTH . 3) (FIFTH . 4)
+    (SIXTH . 5) (SEVENTH . 6) (EIGHTH . 7) (NINTH . 8) (TENTH . 9)) )
+
+(DEFMACRO PUSHNEW (OBJ SYM TEST)
+  (LIST 'SETQ SYM (LIST 'ADJOIN OBJ SYM TEST)) )
+
+
+; Section 5.10:  Definition Primitives
+
+(MOVD 'REMD 'FMAKUNBOUND)
+
+
+; Section 5.11.1:  Character Functions
+
+(DEFUN DIGIT-CHAR-P (SYM N)
+  ((SYMBOLP SYM)
+    ( ((AND (INTEGERP N) (<= 2 N 36)))
+      (SETQ N 10) )
+    ((NUMERIC-CHAR-P SYM)
+      (SETQ SYM (- (ASCII SYM) 48))
+      ((< SYM N) SYM) )
+    ((UPPER-CASE-P SYM)
+      (SETQ SYM (- (ASCII SYM) 55))
+      ((< SYM N) SYM) ) ) )
+
+(DEFUN CHAR-CODE (SYM)
+  ((SYMBOLP SYM)
+    (ASCII SYM) ) )
+
+(DEFUN CODE-CHAR (N)
+  ((AND (INTEGERP N) (<= 0 N 255))
+    (ASCII N) ) )
+
+
+; Section 5.11.2:  String Functions
+
+(DEFMACRO STRING-EQUAL (ATM1 ATM2)
+  (LIST 'STRING= ATM1 ATM2 T) )
+
+(DEFMACRO STRING-LESSP (ATM1 ATM2)
+  (LIST 'STRING< ATM1 ATM2 T) )
+
+(DEFMACRO STRING-GREATERP (ATM1 ATM2)
+  (LIST 'STRING> ATM1 ATM2 T) )
+
+(DEFMACRO STRING-NOT-GREATERP (ATM1 ATM2)
+  (LIST 'STRING<= ATM1 ATM2 T) )
+
+(DEFMACRO STRING-NOT-LESSP (ATM1 ATM2)
+  (LIST 'STRING>= ATM1 ATM2 T) )
+
+(DEFMACRO STRING-NOT-EQUAL (ATM1 ATM2)
+  (LIST 'STRING/= ATM1 ATM2 T) )
+
+
+; Section 5.12:  Arithmetic Functions
+
+(DEFMACRO INCF (PLACE N)
+  ((NULL N)
+    ((ATOM PLACE)
+      (LIST 'INCQ PLACE) )
+    (MAKE-SET-FORM PLACE (LIST 'ADD1 PLACE)) )
+  ((ATOM PLACE)
+    (LIST 'INCQ PLACE N) )
+  (MAKE-SET-FORM PLACE (LIST '+ PLACE N)) )
+
+(DEFMACRO DECF (PLACE N)
+  ((NULL N)
+    ((ATOM PLACE)
+      (LIST 'DECQ PLACE) )
+    (MAKE-SET-FORM PLACE (LIST 'SUB1 PLACE)) )
+  ((ATOM PLACE)
+    (LIST 'DECQ PLACE N) )
+  (MAKE-SET-FORM PLACE (LIST '- PLACE N)) )
+
+
+; Section 5.12.5:  Irrational and Transcendental Functions
+
+(DEFUN GET-CONSTANT (CONSTANT FORM)
+;GET-CONSTANT returns the value of numerical constant, accurate to the
+;current precision.
+  ((EQL (PRECISION) (GET CONSTANT 'PRECISION))
+    (EVAL CONSTANT) )
+  (SET CONSTANT
+       (IF (AND (GET CONSTANT 'PRECISION)
+		(< (PRECISION) (GET CONSTANT 'PRECISION)) )
+	   (/ (NUMERATOR (EVAL CONSTANT)) (DENOMINATOR (EVAL CONSTANT)))
+	   (EVAL FORM) ))
+  (PUT CONSTANT 'PRECISION (PRECISION))
+  (EVAL CONSTANT) )
+
+
+(DEFUN EXP (N)
+;(EXP n) returns e^n, accurate to the current precision.
+  ((NUMBERP N)
+    ((ZEROP N) 1)
+    ((PLUSP (PRECISION))
+      ((MINUSP N)
+	(/ 1 (EXP (- N))) )
+      ((= N 1)
+	(GET-CONSTANT 'E '(EXP-AUX 1)) )
+      ((> N 1)
+	(LET ((Q (DIVIDE (NUMERATOR N) (DENOMINATOR N))))
+	  (* (EXPT-AUX (GET-CONSTANT 'E '(EXP-AUX 1)) (CAR Q))
+	     (EXP-AUX (/ (CDR Q) (DENOMINATOR N)))) ) )
+      (EXP-AUX N) )
+    (BREAK (LIST 'EXP N) "Infinite Precision") )
+  (BREAK (LIST 'EXP N) "Nonnumeric Argument") )
+
+(DEFUN EXP-AUX (N
+;If 0<n<=1, (EXP-AUX n) returns e^n, accurate to the current
+;precision, using the fact that EXP (p/q) =
+;((...(((q+p)2q+p^2)3q+p^3)4q+...+p^(m-1))mq + p^m) / (m! q^m),
+    P Q M TERM NUMR DENR PRECISION BITLENGTH )
+  (SETQ PRECISION (* 32 (PRECISION))
+	M 1
+	P (NUMERATOR N)
+	Q (DENOMINATOR N)
+	TERM P
+	NUMR (+ P Q)
+	DENR Q )
+  (LOOP
+    (INCQ M)
+    (SETQ TERM (* P TERM)
+	  NUMR (+ TERM (* Q NUMR M))
+	  DENR (* Q DENR M)
+	  BITLENGTH (- PRECISION (INTEGER-LENGTH DENR)) )
+    ( ((MINUSP BITLENGTH)
+	(SETQ TERM (SHIFT TERM BITLENGTH)
+	      DENR (SHIFT DENR BITLENGTH)
+	      NUMR (SHIFT NUMR BITLENGTH) ) ) )
+    ((ZEROP TERM)
+      (/ NUMR DENR) ) ) )
+
+(IF (PLUSP (PRECISION)) (EXP 1))		;Initialize the variable E
+
+
+(DEFUN EXPT (N M)
+;(EXPT n m) returns n^m.
+  ((AND (NUMBERP N) (NUMBERP M))
+    ((ZEROP M) 1)
+    ((ZEROP N)
+      ((MINUSP M)
+	(BREAK (LIST 'EXPT N M) "Zero Divide") )
+      0 )
+    ((MINUSP M)
+      (/ 1 (EXPT-AUX N (- M))) )
+    (EXPT-AUX N M) )
+  (BREAK (LIST 'EXPT N M) "Nonnumeric Argument") )
+
+(DEFUN EXPT-AUX (N M
+;If m>0, (EXPT-AUX n m) returns n^m.  If m is a ratio the result may
+;be only an approximation to n^m, accurate to the current precision.
+    ANS )
+  ((= N 1) 1)
+  ((INTEGERP M)
+    ((= M 1) N)
+    (SETQ ANS 1)
+    (LOOP				;Binary power method
+      ( ((ODDP M)
+	  (SETQ ANS (* N ANS)) ) )
+      ((ZEROP (SETQ M (SHIFT M -1))) ANS)
+      (SETQ N (* N N)) ) )
+  ((PLUSP (PRECISION))
+    ((MINUSP N)
+      ((ODDP (DENOMINATOR M))
+	((EVENP (NUMERATOR M))
+	  (EXP (* M (LN-AUX (- N)))) )
+	(- (EXP (* M (LN-AUX (- N))))) )
+      (BREAK (LIST 'EXPT N M) "Invalid Argument") )
+    (EXP (* M (LN-AUX N))) )
+  (BREAK (LIST 'EXPT N M) "Infinite Precision") )
+
+
+(DEFUN LOG (N M)
+;(LOG n m) returns base m logarithm of n.  m defaults to e, the base
+;of the natural logarithms.
+  (SETQ N (LN N))
+  ((NULL M) N)
+  ((ZEROP M) 0)
+  (/ N (LN M)) )
+
+(DEFUN LN (N)
+;(LN n) returns ln n, the natural logarithm of n.
+  ((NUMBERP N)
+    ((PLUSP N)
+      ((= N 1) 0)
+      ((PLUSP (PRECISION))
+	((= N 2)
+	  (GET-CONSTANT 'LN2 '(LN-AUX 2)) )
+	(LN-AUX N) )
+      (BREAK (LIST 'LN N) "Infinite Precision") )
+    (BREAK (LIST 'LN N) "Invalid Argument") )
+  (BREAK (LIST 'LN N) "Nonnumeric Argument") )
+
+(DEFUN LN-AUX (N
+;If n>0, (LN-AUX n) returns ln n, accurate to the current precision,
+;using the fact that with p/q = (x-1)/(x+1) = u,
+;LN x = 2 (u + u^3/3 + u^5/5 + ... + u^m/m) =
+;(...(((6pq^2 + 2p^3)5q^2 + 2 3p^5)7q^2 + 2 3 5p^7)9q^2 +
+;	...+2 3 5 ...(m-2)p^m) / (3 5 ...m q^m),
+    P Q PLEN QLEN SHIFT M TERM NUMR DENR PRECISION BITLENGTH )
+  ((= N 2)
+    (SETQ PRECISION (* 32 (PRECISION))
+	  M 11
+	  TERM 945
+	  NUMR 638195436
+	  DENR 1841443065 )
+; LN 2 ~= (2/9) (1 + (1/9)/3 + (1/9)^2/5 + ... + (1/9)^m/(2m+1)) =
+;   2 (...(((9 3 + 1)9 5 + 3)9 7 + 3 5)9 9 + ... + 3 5 ...(2m-1))
+;   / (3 5 ...(2m+1) 3^(2m+1)),  with single-precision head start
+    (LOOP
+      (SETQ TERM (* M TERM)
+	    M (+ M 2)
+	    NUMR (+ TERM (* 9 M NUMR))
+	    DENR (* 9 M DENR)
+	    BITLENGTH (- PRECISION (INTEGER-LENGTH NUMR)) )
+      ( ((MINUSP BITLENGTH)
+	  (SETQ	TERM (SHIFT TERM BITLENGTH)
+		NUMR (SHIFT NUMR BITLENGTH)
+		DENR (SHIFT DENR BITLENGTH) ) ) )
+      ((ZEROP TERM)
+	(/ (SHIFT NUMR 1) DENR) ) ) )
+  ((< (NUMERATOR N) (DENOMINATOR N))
+    (- (LN-AUX (/ 1 N))) )
+  (SETQ PRECISION (* 32 (PRECISION))
+	SHIFT 0
+	P (NUMERATOR N)
+	Q (DENOMINATOR N)
+	PLEN (INTEGER-LENGTH P)
+	QLEN (INTEGER-LENGTH Q) )
+  ( ((> PLEN QLEN)			;Make  3/4 < N <= 3/2:
+      ((> (SHIFT P 1) (* 3 Q))
+	(SETQ SHIFT (- PLEN QLEN))
+	((> PLEN PRECISION)
+	  (SETQ P (SHIFT P (- PRECISION PLEN))
+		Q (SHIFT Q (- PRECISION QLEN)))
+	  ((> (SHIFT P 1) (* 3 Q))
+	    (SETQ SHIFT (ADD1 SHIFT)
+		  N (/ P (SHIFT Q 1))) )
+	  ((< (SHIFT P 2) (* 3 Q))
+	    (SETQ SHIFT (SUB1 SHIFT)
+		  N (/ P (SHIFT Q -1))) )
+	  (SETQ N (/ P Q)) )
+	((> (SHIFT P 1) (* 3 (SETQ Q (SHIFT Q SHIFT))))
+	  (SETQ SHIFT (ADD1 SHIFT)
+		N (/ P (SHIFT Q 1))) )
+	((< (SHIFT P 2) (* 3 Q))
+	  (SETQ SHIFT (SUB1 SHIFT)
+		N (/ P (SHIFT Q -1))) )
+	(SETQ N (/ P Q)) ) )
+    ((> (SHIFT P 1) (* 3 Q))
+      (SETQ SHIFT 1
+	    N (/ P (SHIFT Q 1))) ) )
+  (SETQ N (/ (- (NUMERATOR N) (DENOMINATOR N))
+	     (+ (NUMERATOR N) (DENOMINATOR N)))
+	PLEN (* N N)
+	P (NUMERATOR PLEN)
+	Q (DENOMINATOR PLEN)
+	NUMR (SHIFT (NUMERATOR N) 1)
+	TERM NUMR
+	DENR (DENOMINATOR N)
+	PRECISION (- PRECISION (INTEGER-LENGTH SHIFT))
+	M 1)
+  (LOOP
+    (SETQ TERM (* M TERM P)
+	  M (+ M 2)
+	  NUMR (+ TERM (* NUMR Q M))
+	  DENR (* M Q DENR)
+	  BITLENGTH (- PRECISION (INTEGER-LENGTH NUMR)))
+    ( ((MINUSP BITLENGTH)
+	(SETQ TERM (SHIFT TERM BITLENGTH)
+	      NUMR (SHIFT NUMR BITLENGTH)
+	      DENR (SHIFT DENR BITLENGTH)) ) )
+    ((ZEROP TERM)
+      ((ZEROP SHIFT)
+	(/ NUMR DENR) )
+      (+ (* SHIFT (GET-CONSTANT 'LN2 '(LN-AUX 2))) (/ NUMR DENR)) ) ) )
+
+(IF (PLUSP (PRECISION)) (LN 2))		;Initialize the variable LN2
+
+
+(DEFUN SQRT (N)
+;If n is positive, (SQRT n) returns square root of n.
+  (EXPT N 1/2) )
+
+
+(DEFUN ISQRT (N)
+;If n is a nonnegative integer, (ISQRT n) returns the greatest integer
+;less than or equal to the positive square root of n.
+  ((INTEGERP N)
+    ((>= N 0)
+      ((= N 0) 0)
+      (ISQRT-AUX N) )
+    (BREAK (LIST 'ISQRT N) "Invalid Argument") )
+  (BREAK (LIST 'ISQRT N) "Noninteger Argument") )
+
+(DEFUN ISQRT-AUX (N
+;If n is a positive integer, (ISQRT-AUX n) returns the greatest integer
+;less than or equal to n^(1/2).  ISQRT-AUX uses Newton's method.
+    SHIFT INC ANS)
+  (SETQ ANS 1
+	INC 1
+	SHIFT (* (- (TRUNCATE (SUB1 (INTEGER-LENGTH N)) 2)) 2) )
+  (LOOP		;Start with 1-bit precision & repeatedly doubling
+    ((ZEROP SHIFT))
+    (SETQ ANS (SHIFT ANS INC)
+	  SHIFT (+ SHIFT (SHIFT INC 1))
+	  ANS (+ ANS (FLOOR (- (SHIFT N SHIFT) (* ANS ANS)) (* 2 ANS)))
+	  INC (MIN (SHIFT INC 1) (TRUNCATE (- SHIFT) 2)) ) )
+  ((<= (* ANS ANS) N) ANS)
+  (SUB1 ANS) )
+
+(DEFUN PI ()
+;(PI) returns pi, accurate to the current precision.
+  ((PLUSP (PRECISION))
+    (GET-CONSTANT 'PI '(PI-AUX)) )
+  (BREAK (CONS 'PI) "Infinite Precision") )
+
+(DEFUN PI-AUX (
+;(PI-AUX) returns pi, using the fact that 4/pi =
+;SIGMA ((-1)^m (1123 + 21460 m) (1 3 ...(2m-1)) (1 3 ...(4m-1))
+;  / ((882^(2m+1) 32^m (m!)^3), m, 0, PINF), rearranged over a common
+;denominator (Ramanujan, Quart. J. Pure & Appl. Math. 45, p. 350, 1914).
+    N M TERM NUMR DENR PRECISION BITLENGTH )
+  (SETQ PRECISION (* 32 (PRECISION))
+	M 0
+	N 1123
+	TERM 1
+	NUMR 3528
+	DENR N )
+  (LOOP
+    (INCQ M)
+    (SETQ N (+ N 21460)
+	  TERM (* TERM (- (+ M M) 1) (- 1 (* 4 M)) (- (* 4 M) 3))
+	  BITLENGTH (* M M M 24893568)
+	  NUMR (* NUMR BITLENGTH)
+	  DENR (+ (* DENR BITLENGTH) (* N TERM))
+	  BITLENGTH (- (+ PRECISION (INTEGER-LENGTH N)) (INTEGER-LENGTH DENR)) )
+    ( ((MINUSP BITLENGTH)
+	(SETQ TERM (SHIFT TERM BITLENGTH)
+	      DENR (SHIFT DENR BITLENGTH)
+	      NUMR (SHIFT NUMR BITLENGTH)) ) )
+    ((ZEROP TERM)
+      (/ NUMR DENR) ) ) )
+
+(IF (PLUSP (PRECISION)) (PI))		;Initialize the variable PI
+
+
+(DEFUN SIN (N
+; (SIN n) returns the sine of n radians.
+    Q )
+  ((NUMBERP N)
+    ((ZEROP N) 0)
+    ((PLUSP (PRECISION))
+      (SETQ Q (/ N (/ (PI) 4))
+	    N (DIVIDE (NUMERATOR Q) (DENOMINATOR Q)))
+      (SINCOS (MOD (CAR N) 8) (/ (CDR N) (DENOMINATOR Q))) )
+    (BREAK (LIST 'SIN N) "Infinite Precision") )
+  (BREAK (LIST 'SIN N) "Nonnumeric Argument") )
+
+(DEFUN COS (N
+; (COS n) returns the cosine of n radians.
+    Q )
+  ((NUMBERP N)
+    ((ZEROP N) 1)
+    ((PLUSP (PRECISION))
+      (SETQ Q (/ N (/ (PI) 4))
+	    N (DIVIDE (NUMERATOR Q) (DENOMINATOR Q)))
+      (SINCOS (MOD (+ 2 (CAR N)) 8) (/ (CDR N) (DENOMINATOR Q))) )
+    (BREAK (LIST 'COS N) "Infinite Precision") )
+  (BREAK (LIST 'COS N) "Nonnumeric Argument") )
+
+(DEFUN TAN (N)
+; (TAN n) returns the tangent of n radians.
+  (/ (SIN N) (COS N)) )
+
+
+(DEFUN SINCOS (N Q)
+; Returns the sine or cosine of an appropriately reduced angle.
+  ((> N 3)
+    (- (SINCOS (- N 4) Q)) )
+  ((ZEROP N)
+    (SETQ Q (* Q (/ (PI) 4)))
+    (SINCOS-AUX Q 1 (NUMERATOR Q) (DENOMINATOR Q)) )
+  ((EQ N 1)
+    (SINCOS-AUX (* (- 1 Q) (/ (PI) 4)) 0 1 1) )
+  ((EQ N 2)
+    (SINCOS-AUX (* Q (/ (PI) 4)) 0 1 1) )
+  (SETQ Q (* (- 1 Q) (/ (PI) 4)))
+  (SINCOS-AUX Q 1 (NUMERATOR Q) (DENOMINATOR Q)) )
+
+(DEFUN SINCOS-AUX (ARG N NUMR DENR
+; (SIN1 n) returns the sine of n radians, where 0 <= n <= pi/4 radians.
+; SIN (x=p/q) ~= x - x^3/3! + x^5/5! - ... +|- x^n/n! =
+; ((...((2*3pq^2 - p^3)4*5q^2 + p^5)6*7q^2 - ...)(n-1)nq^2 +|- p^n) / (n! q^n)
+; (COS1 n) returns the cosine of n radians, where 0 <= n <= pi/4 radians.
+; COS (x=p/q) ~= 1 - x^2/2! + x^3/3! - ... +|- x^n/n! =
+; ((...((2q^2 - p^2)3*4q^2 + p^4)5*6q^2 - ...)(n-1)nq^2 +|- p^n) / (n! q^n)
+    MNARGSQ DARGSQ TERM PRECISION BITLENGTH )
+  (SETQ PRECISION (* 32 (PRECISION))
+	DARGSQ (* ARG ARG)
+	MNARGSQ (- (NUMERATOR DARGSQ))
+	DARGSQ (DENOMINATOR DARGSQ)
+	TERM NUMR)
+  (LOOP
+    (SETQ N (+ N 2)
+	  ARG (* (SUB1 N) N)
+	  DENR (* ARG DARGSQ DENR)
+	  TERM (* MNARGSQ TERM)
+	  NUMR (+ (* ARG DARGSQ NUMR) TERM)
+	  BITLENGTH (- PRECISION (INTEGER-LENGTH NUMR)))
+    ( ((MINUSP BITLENGTH)
+	(SETQ TERM (SHIFT TERM BITLENGTH)
+	      NUMR (SHIFT NUMR BITLENGTH)
+	      DENR (SHIFT DENR BITLENGTH)) ) )
+    ((ZEROP TERM)
+      (/ NUMR DENR) ) ) )
+
+
+(DEFUN ASIN (N)
+; (ASIN n) returns the inverse sine of n in radians.  Note that
+; for all -1 <= n <= 1, -pi/2 <= (ASIN n) <= pi/2.
+  ((NUMBERP N)
+    ((PLUSP (PRECISION))
+      ((MINUSP N)
+	(- (ASIN (- N))) )
+      ((= N 1)
+	(/ (PI) 2) )
+      ((< N 1)
+	(ATAN (NUMERATOR N)
+	      (SQRT (* (- (DENOMINATOR N) (NUMERATOR N))
+		       (+ (DENOMINATOR N) (NUMERATOR N))))) )
+      (BREAK (LIST 'ASIN N) "Invalid Argument") )
+    (BREAK (LIST 'ASIN N) "Infinite Precision") )
+  (BREAK (LIST 'ASIN N) "Nonnumeric Argument") )
+
+(DEFUN ACOS (N)
+; (ACOS n) returns the inverse cosine of n in radians.  Note that
+; for all -1 <= n <= 1, 0 <= (ACOS n) <= pi.
+  ((NUMBERP N)
+    ((= N 1) 0)
+    ((PLUSP (PRECISION))
+      ((= N -1)
+	(PI) )
+      ((<= -1 N 1)
+	((< (ABS N) 1)
+	  (ATAN (SQRT (* (- (DENOMINATOR N) (NUMERATOR N))
+			 (+ (DENOMINATOR N) (NUMERATOR N)) ))
+		(NUMERATOR N)) ) )
+      (BREAK (LIST 'ACOS N) "Invalid Argument") )
+    (BREAK (LIST 'ACOS N) "Infinite Precision") )
+  (BREAK (LIST 'ACOS N) "Nonnumeric Argument") )
+
+
+(DEFUN ATAN (N M
+; (ATAN n m) returns in radians the angle corresponding to the vector
+; whose opposite component is n and whose adjacent component is m.
+; m defaults to 1.  Note that for all n and m, -pi < (ATAN n m) <= pi.
+; With v = x/(1+x^2) = r/s,  u = xv = p/q,  ATAN (x) ~=
+; (1 + 2u/3 + 2 4u^2/(3 5) +...+ 2 4 ...(2n)u^n/(3 5 ...(2n+1))) v =
+; ((...((3rq + 2rp)5q + 2 4rp^2)7q +...)(2n+1)q + 2 4 ...(2n)rp^n)
+; / (3 5 ...(2n+1)sq^n)
+   INDX NUMR TERM DENR NARG DARG PRECISION BITLENGTH )
+  ((PLUSP (PRECISION))
+    ((NUMBERP N)
+      ((NUMBERP M)	;Reduce two-argument case to one argument
+	((PLUSP M)
+	  (ATAN (/ N M)) )
+	((ZEROP M)
+	  ((PLUSP N)
+	    (/ (PI) 2) )
+	  ((MINUSP N)
+	    (/ (PI) -2) )
+	  (BREAK (LIST 'ATAN N M) "Invalid Argument") )
+	((ZEROP N)
+	  (PI) )
+	((MINUSP N)
+	   (- (/ (PI) -2) (ATAN (/ M N))) )
+	(+ (/ (PI) 2) (ATAN (/ (- M) N))) )
+      ((NULL M)
+	((MINUSP N)
+	  (- (ATAN (- N))) )
+	((> N 1)
+	  (- (/ (PI) 2) (ATAN (/ 1 N))) )
+	(SETQ PRECISION (* 32 (PRECISION))
+	      M (/ N (ADD1 (* N N)))
+	      N (* N M)
+	      NARG (NUMERATOR N)
+	      DARG (DENOMINATOR N)
+	      INDX 1
+	      NUMR (NUMERATOR M)
+	      TERM NUMR
+	      DENR (DENOMINATOR M) )
+	(LOOP
+	  (INCQ INDX 2)
+	  (SETQ TERM (* (SUB1 INDX) NARG TERM)
+		NUMR (+ TERM (* INDX DARG NUMR))
+		DENR (* INDX DARG DENR)
+		BITLENGTH (- PRECISION (INTEGER-LENGTH NUMR)))
+	  ( ((MINUSP BITLENGTH)
+	      (SETQ NUMR (SHIFT NUMR BITLENGTH)
+		    DENR (SHIFT DENR BITLENGTH)
+		    TERM (SHIFT TERM BITLENGTH)) ) )
+	  ((ZEROP TERM)
+	    (/ NUMR DENR) ) ) )
+      (BREAK (LIST 'ATAN N M) "Nonnumeric Argument") )
+    (BREAK (LIST 'ATAN N M) "Nonnumeric Argument") )
+  (BREAK (LIST 'ATAN N M) "Infinite Precision") )
+
+
+; Section 5.12.7:  Bitwise Logical Functions
+
+(MOVD 'SHIFT 'ASH)
+
+
+; Section 5.12.8:  Random Numbers
+
+(DEFUN RANDOM (N STATE
+    BL COUNT ANS)
+  (IF (RANDOM-STATE-P STATE)
+      (SETQ *RANDOM-STATE* STATE) )
+  (SETQ *RANDOM-STATE*
+		(LOGAND (ADD1 (* 3141592653 *RANDOM-STATE*)) 4294967295))
+  ((AND (INTEGERP N) (PLUSP N))
+    (SETQ ANS *RANDOM-STATE*
+	  BL (- -10 (INTEGER-LENGTH N))
+	  COUNT 0)
+    (LOOP			; concatenate 32-bit random integers
+      ((> BL (DECQ COUNT 32))
+	(SHIFT (* N ANS) COUNT) )
+      (SETQ *RANDOM-STATE*
+	      (LOGAND (ADD1 (* 3141592653 *RANDOM-STATE*)) 4294967295)
+	    ANS (+ (SHIFT ANS 32) *RANDOM-STATE*)) ) )
+  ((NUMBERP N)
+    (SETQ ANS (SHIFT 1 (- (* 32 (MAX (PRECISION) 1)) 10)))
+    (/ (* (ABS N) (RANDOM ANS)) ANS) ) )
+
+(DEFUN MAKE-RANDOM-STATE (STATE)
+  ((NULL STATE) *RANDOM-STATE*)
+  ((EQ STATE 'T)
+    (TIME) )
+  ((RANDOM-STATE-P STATE) STATE) )
+
+(SETQ *RANDOM-STATE* (MAKE-RANDOM-STATE 'T))
+
+(DEFUN RANDOM-STATE-P (OBJ)
+  (AND (INTEGERP OBJ) (>= OBJ 0)) )
+
+
+; Section 5.13.2:  Input Functions
+
+(SETQ *LPAR* '\()
+(SETQ *RPAR* '\))
+
+(DEFUN READ-BACKQUOTE (
+; This backquote facility conforms to the Common LISP standard except
+; that nested backquote forms are not supported.  See Section 22.1.3
+; of Common LISP by Steele [1984].
+    CHAR FORM-LIST )
+  (SETQ CHAR (PEEK-CHAR T))
+  ((EQ CHAR '\,)
+    (READ-CHAR)
+    (SETQ CHAR (PEEK-CHAR))
+    ((OR (EQ CHAR '\@) (EQ CHAR '\.))
+      (BREAK CHAR "Syntax Error") )
+    (READ) )
+  ((NEQ CHAR *LPAR*)
+    (LIST 'QUOTE (READ)) )
+  (READ-CHAR)
+  (LOOP
+    (SETQ CHAR (PEEK-CHAR T))
+    ((EQ CHAR *RPAR*)
+      (READ-CHAR)
+      ((NULL FORM-LIST) NIL)
+      ((NULL (CDR FORM-LIST))
+	(CAR FORM-LIST) )
+      (CONS 'NCONC (NREVERSE FORM-LIST)) )
+    ((EQ CHAR '\.)
+      (READ-CHAR)
+      (SETQ CHAR (PEEK-CHAR T))
+      ((EQ CHAR '\,)
+	(READ-CHAR)
+	(SETQ CHAR (PEEK-CHAR))
+	((OR (EQ CHAR '\@) (EQ CHAR '\.))
+	  (BREAK CHAR "Syntax Error") )
+	(PUSH (READ) FORM-LIST)
+	((EQ (READ-CHAR) *RPAR*)
+	  (CONS 'NCONC (NREVERSE FORM-LIST)) )
+	(BREAK '\. "Syntax Error") )
+      (PUSH (READ-BACKQUOTE) FORM-LIST)
+      ((EQ (READ-CHAR) *RPAR*)
+	(CONS 'NCONC (NREVERSE FORM-LIST)) )
+      (BREAK '\. "Syntax Error") )
+    ( ((EQ CHAR '\,)
+	(READ-CHAR)
+	(SETQ CHAR (PEEK-CHAR))
+	((EQ CHAR '\@)
+	  (READ-CHAR)
+	  (PUSH (READ) FORM-LIST)
+	  ((EQ (PEEK-CHAR T) *RPAR*))
+	  (PUSH (LIST 'COPY-LIST (POP FORM-LIST)) FORM-LIST) )
+	((EQ CHAR '\.)
+	  (READ-CHAR)
+	  (PUSH (READ) FORM-LIST) )
+	(PUSH (LIST 'LIST (READ)) FORM-LIST) )
+      (PUSH (LIST 'LIST (READ-BACKQUOTE)) FORM-LIST) ) ) )
+
+(SET-MACRO-CHAR '\` '(LAMBDA ()
+  (READ-BACKQUOTE) ))
+
+
+; Section 5.15.1:  Evaluation Recognizers
+
+(DEFUN EVAL-FUNCTION-P (SYM)
+  (EQ (GETD SYM T) 'LAMBDA) )
+
+(DEFUN NO-EVAL-FUNCTION-P (SYM)
+  (EQ (GETD SYM T) 'NLAMBDA) )
+
+(DEFUN MACRO-FUNCTION-P (SYM)
+  (EQ (GETD SYM T) 'MACRO) )
+
+(DEFUN SPECIAL-FORM-P (SYM)
+  (EQ (GETD SYM T) 'SPECIAL) )
+
+(DEFUN FBOUNDP (SYM)
+  (GETD SYM T) )
+
+(DEFUN FUNCTIONP (OBJ)
+  ((SYMBOLP OBJ))
+  ((ATOM OBJ) NIL)
+  (EQ (CAR OBJ) 'LAMBDA) )
+
+
+; Section 5.15.2:  Evaluation and Function Application
+
+(DEFUN SYMBOL-VALUE (SYM)
+  ((SYMBOLP SYM)
+    (CAR SYM) ) )
+
+(DEFUN SYMBOL-PLIST (SYM)
+  ((SYMBOLP SYM)
+    (CDR SYM) ) )
+
+(DEFUN SYMBOL-FUNCTION (SYM)
+  ((SYMBOLP SYM)
+    ((FBOUNDP SYM)
+      (GETD SYM) )
+    (BREAK (LIST 'SYMBOL-FUNCTION SYM) "Undefined Function") ) )
+
+
+; Section 5.15.3:  Macro Expansion Functions
+
+(DEFUN MACRO-FUNCTION (SYM)
+  ((MACRO-FUNCTION-P SYM)
+    (GETD SYM) ) )
+
+
+; Section 5.16:  Control Constructs
+
+(DEFMACRO PROG2 (FORM1 . FORMS)
+  (LIST 'PROGN FORM1 (CONS 'PROG1 FORMS)) )
+
+(DEFMACRO WHEN (TEST . BODY)
+  (LIST 'IF TEST (CONS 'PROGN BODY)) )
+
+(DEFMACRO UNLESS (TEST . BODY)
+  (LIST 'IF TEST NIL (CONS 'PROGN BODY)) )
+
+(DEFMACRO LET (LETLIST . BODY)
+   (CONS (LIST* 'LAMBDA
+		(MAPCAR 'CAR LETLIST)
+		BODY)
+	 (MAPCAR 'CADR LETLIST)) )
+
+(DEFMACRO LET* (LETLIST . BODY)
+   (LIST (LIST* 'LAMBDA
+		(MAPCAR 'CAR LETLIST)
+		(CONS 'SETQ
+		      (MAPCAN '(LAMBDA (LST) (LIST (CAR LST) (CADR LST)))
+			      LETLIST))
+		BODY)) )
+
+(DEFMACRO DO (LETLIST . BODY)
+  (CONS (LIST 'LAMBDA
+	      (MAPCAR '(LAMBDA (VAR) (IF (ATOM VAR) VAR (CAR VAR))) LETLIST)
+	      (CONS 'LOOP
+		    (APPEND BODY (LIST (CONS 'PSETQ
+			(MAPCAN '(LAMBDA (VAR)
+				   ((ATOM VAR) NIL)
+				   ((CADDR VAR)
+				     (LIST (CAR VAR) (CADDR VAR)) ) )
+				LETLIST))))))
+	(MAPCAR '(LAMBDA (VAR) (IF (ATOM VAR) NIL (CADR VAR))) LETLIST)) )
+
+(DEFMACRO DO* (LETLIST . BODY)
+  (LIST (LIST 'LAMBDA
+	      (MAPCAR '(LAMBDA (VAR) (IF (ATOM VAR) VAR (CAR VAR)))
+		      LETLIST)
+	      (CONS 'SETQ
+		    (MAPCAN '(LAMBDA (VAR)
+			       ((ATOM VAR)
+				 (LIST VAR NIL) )
+			       (LIST (CAR VAR) (CADR VAR)))
+			    LETLIST))
+	      (CONS 'LOOP
+		    (APPEND BODY (LIST (CONS 'SETQ
+			(MAPCAN '(LAMBDA (VAR)
+				   ((ATOM VAR) NIL)
+				   ((CADDR VAR)
+				     (LIST (CAR VAR) (CADDR VAR)) ) )
+				LETLIST))))))) )
+
+(DEFMACRO DOLIST ((VAR LISTFORM RSLTFORM) . BODY)
+  (LET ((DOLIST (GENSYM)))
+    (LIST 'LET
+	  (LIST (LIST DOLIST LISTFORM))
+	  (LIST* 'LOOP
+		 (LIST (LIST 'ATOM DOLIST) RSLTFORM)
+		 (LIST 'SETQ VAR (LIST 'POP DOLIST))
+		 BODY)) ) )
+
+(DEFMACRO DOTIMES ((VAR COUNTFORM RSLTFORM) . BODY)
+  (LET ((DOTIMES (GENSYM)))
+    (LIST 'LET
+	  (LIST (LIST VAR 0)
+		(LIST DOTIMES COUNTFORM))
+	  (LIST* 'LOOP
+		 (LIST (LIST '>= VAR DOTIMES) RSLTFORM)
+		 (APPEND BODY (LIST (LIST 'INCQ VAR))))) ) )
+
+
+; PROG [var-list, expn1, expn2, ..., expnm]  sets the local variables
+; in <var-list> to NIL and sequentially evaluates <expn1> through <expnm>,
+; unless the functions GO or RETURN are encountered.  This PROG interpreter
+; is included for completeness.  We strongly recommend that functions using
+; PROG be translated into equivalent muLISP functions using the LOOP
+; construct, since the resulting function will be much more efficient.
+
+(DEFUN PROG (NLAMBDA LST$
+  (EVAL (LIST (CONS 'LAMBDA (LIST (CAR LST$) (LIST 'PROG-AUX
+      '(CDR LST$)))))) ))
+
+(DEFUN PROG-AUX (BDY$
+    LST$ GO-LABEL$ ANS$)
+  (SETQ LST$ BDY$)
+  (LOOP
+    ((NULL LST$) ANS$)
+    (SETQ ANS$ (EVAL (POP LST$)))
+    ( ((NULL GO-LABEL$))
+      (SETQ LST$ (CDR (MEMBER GO-LABEL$ BDY$))
+	    GO-LABEL$) ) ) )
+
+
+;GO [label]  if within a PROG, transfers control to the expression in
+;the PROG body immediately following <label>.
+
+(DEFUN GO (NLAMBDA (LABEL$)
+  (SETQ GO-LABEL$ LABEL$) ))
+
+
+(SETQ *COMMMAND-DRIVE* "")
+
+(DEFUN DOS (COMMAND
+; (DOS command) executes the MS-DOS <command>, and returns the exit code.
+; If the MS-DOS command processor is not on the default drive, the user
+; is prompted for the drive containing COMMAND.COM.  See the EXECUTE
+; function in Section 5.16 for an example using DOS.
+    READ-CHAR RDS WRS )
+  (LOOP
+    ((EXECUTE (PACK* *COMMAND-DRIVE* "COMMAND.COM")
+	      (IF COMMAND (PACK* "/C " COMMAND))))
+    (FRESH-LINE)
+    (WRITE-STRING "Enter COMMAND.COM drive letter: ")
+    (SETQ *COMMAND-DRIVE* (PRINC (CHAR-UPCASE (READ-CHAR))))
+    (TERPRI)
+    ((NOT (ALPHA-CHAR-P *COMMAND-DRIVE*)) NIL)
+    (SETQ *COMMAND-DRIVE* (PACK* *COMMAND-DRIVE* '\:)) ) )
+
+
+; Section 22.4:  Querying the User
+
+(DEFUN Y-OR-N-P (MSG
+    CHAR READ-CHAR RDS WRS )
+  ( ((NULL MSG))
+    (FRESH-LINE)
+    (WRITE-STRING (PACK* MSG " (Y/N) ")) )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    ((EQ CHAR 'Y) (WRITE-LINE CHAR) T)
+    ((EQ CHAR 'N) (WRITE-LINE CHAR) NIL)
+    (WRITE-BYTE 7) ) )
+
+(DEFUN YES-OR-NO-P (MSG
+    LINE READ-CHAR RDS WRS )
+  (SETQ READ-CHAR T)
+  (CLEAR-INPUT)
+  (LOOP
+    ( ((NULL MSG))
+      (FRESH-LINE)
+      (WRITE-STRING (PACK* MSG " (Yes or No) ")) )
+    (WRITE-BYTE 7)
+    (SETQ LINE (CHAR-UPCASE (READ-LINE)))
+    ((EQ LINE 'YES) T)
+    ((EQ LINE 'NO) NIL) ) )
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/COMTOEXE.COM b/Microsoft muLISP-86 v51/COMTOEXE.COM
new file mode 100644
index 0000000000000000000000000000000000000000..cc576f21ecf8412642ec758fc891503a7925bd10
GIT binary patch
literal 1564
zcmeHG&ubGw6n@)mQ(25H2nq`2truHK(-th$T8cJJZNZR`q!_D3mdzxtZf4{DDCQta
z^<sPS>dBaYAe3AT9ty$s;#PwQ3f{bIPS%ST4{;{3rH6oc)`6XQJ8$0izWLsp*C2S$
zeBoFW=QW+6ZD1rF>DXa|t`gJI42ny(rfYT)hsMs2j*X8_P7DVm@UHv9MxkhGx!X1l
zg@<wc!sG-dWAiDzb~zDQh%F@}L0qJ2C?H9&HnRd~`<e@aC;L(cIu^@zTeHyVU<a{i
zIGA@V8#SuxPKLV)QYBB&$hK|HGRs&7B#rKGq+*<}YUJ|@&4dtBEG9!NTce82nP*IG
zl^{!_P&5jBOVI<8MO1@kP%(2(o=}^`%^N0?`%1o`lOR_iM<_8ByF-E}WxB*8iByQC
z3rGjRvs0KgjeMKU;Zuxi5E(Kt+pcJGWG<H6r#Z#+!1iFrIv41G<1BZ@b)s-_%pxi|
zMWYwdB(`HxjpjHr2E@c~z7byN@N!pNn<0Qs|F)k%c-x<a*tS0h(b`R@_Pg?Q%Ng-D
zg?-_W8a8GPhi1BC-V;hXY#gJ|+Y%l(pwVo6`qOu*JkY!2zXJm7_#XhU`5~K2D^PwX
zmTp10A(j*<e-KM5ls}5KU9oziO)KP`7UneTE@m{7sJ6i_n{{-(JFm|S_KV0<d=q(!
z?`*Ce?X8}2<yX+dL5E!V$(A!%gCm{IJubjmSN@tl@Y+po4!AO3j=Qq=92TkNWV4#8
zu}U!_jEz-LRKg@O+s}Ykv^%3K@Egoa!J&7;`j9n{&4PGWwj07yR!MicE70tNN}o3k
z6`^|7m0hd^yiuq~&2#W{@U3_w?n#hNZZNa%orLwi@R=>=N8R&*{j;9fY*qcPyj+hb
q*56lqn3b+G;X7@GJU#pS%Mo4f1Ry{UJlboqq5=qP{XhOm1%3g<5o!Pc

literal 0
HcmV?d00001

diff --git a/Microsoft muLISP-86 v51/DEBUG.LSP b/Microsoft muLISP-86 v51/DEBUG.LSP
new file mode 100644
index 0000000..5002aab
--- /dev/null
+++ b/Microsoft muLISP-86 v51/DEBUG.LSP	
@@ -0,0 +1,244 @@
+; File:  DEBUG.LSP  (c)		08/15/85	Soft Warehouse, Inc.
+
+
+(LOOP (PRIN1 '*) (EVAL (READ)) ((NULL RDS)) )
+
+
+(DEFUN TRACE LST
+  (STUB 'TRACE LST) )
+
+(DEFUN BRK LST
+  (STUB 'BRK LST) )
+
+(DEFUN CLEAR LST
+  (UNSTUB LST) )
+
+(DEFUN HISTORY (
+    LST)
+  (SETQ! LST (CAR! HISTORY))
+  (LOOP!
+    ((EQ! LST))
+    ( ((EQ! (CAR! LST)))
+      (APPLY! (CAR! (CAR! LST)) (CDR! (CAR! LST))) )
+    (POP! LST) ) )
+
+(SETQ HISTLEN 15)
+
+(DEFUN BACKTRACE (
+    LST)
+  (SETQ! LST (REVERSE! BTRLIST))
+  (LOOP!
+    ((EQ! LST))
+    (APPLY! PRTCALL! (LIST! (CAR! (CAR! LST)) (CDR! (POP! LST)))) ) )
+
+(DEFUN STUB (FLAG LST NAM
+    NAM$)
+  (SET FLAG T)
+  (SETQ NAM$ T)
+  (LOOP
+    ((ATOM LST) NAM$)
+    (SETQ NAM (POP LST))
+    ( ((NOT (GETD NAM T))
+	(SETQ NAM$)
+	(PRIN1 NAM) (WRITE-LINE " is undefined") )
+      (FLAG FLAG NAM)
+      ((TRACED NAM))
+      (PUT NAM 'DEBUG (CONS! (PACK* NAM '!) (COND
+	  ((NUMBERP (GETD NAM)) NIL)
+	  ((CADR (GETD NAM))) )))
+      (MOVD NAM (CAR! (GET NAM 'DEBUG)))
+      (PUTD NAM (LIST
+		(IF (EQ (GETD NAM T) 'SPECIAL) 'NLAMBDA (GETD NAM T))
+		'ARGLST! (LIST 'TRACE! NAM))) ) ) )
+
+(DEFUN TRACED (NAM)
+  (EQ (CAR (CADDR (GETD NAM))) 'TRACE!) )
+
+(DEFUN UNSTUB (LST NAM)
+  (SETQ LEVELCOUNT 0)
+  (RPLACD 'LEVELCOUNT)
+  (SETQ BTRLIST)
+  (LOOP
+    ((ATOM LST))
+    (SETQ NAM (POP LST))
+    ( ((GET NAM 'DEBUG)
+	(REMFLAG 'BRK NAM)
+	(REMFLAG 'TRACE NAM)
+	(MOVD (CAR! (GET NAM 'DEBUG)) NAM)
+	(REMPROP NAM 'DEBUG) ) ) ) )
+
+
+(DEFUN TRACE! (NLAMBDA (NAM!
+    LST!)
+  ( ((AND! (EQ! LEVELCOUNT 0) RATOM)
+      (SETQ! RATOM)
+      (SETQ! HISTORY)
+      (SETQ! CALLCOUNT 0)
+      (RPLACD! 'CALLCOUNT)
+      (SETQ! MAXLEVELCOUNT 0)
+      (RPLACD! 'MAXLEVELCOUNT) ) )
+  (PUTADD! 'CALLCOUNT NAM!)
+  (PUTADD! 'LEVELCOUNT NAM!)
+  ( ((<! LEVELCOUNT MAXLEVELCOUNT))
+    (SETQ! MAXLEVELCOUNT LEVELCOUNT) )
+  ( ((AND! (NUMBERP! (GET! 'MAXLEVELCOUNT NAM!))
+	   (<! (GET! 'LEVELCOUNT NAM!) (GET! 'MAXLEVELCOUNT NAM!))))
+    (PUT! 'MAXLEVELCOUNT NAM! (GET! 'LEVELCOUNT NAM!)) )
+  ( ((EQ! BACKTRACE))
+    (PUSH! (CONS! NAM! ARGLST!) BTRLIST) )
+  (HISTORY! NAM! ARGLST! LEVELCOUNT 'PRTCALL!)
+  ( ((TRACEP! NAM!)
+      (PRTCALL! NAM! ARGLST! LEVELCOUNT) ) )
+  ( ((AND! BRK
+	(FLAGP! 'BRK NAM!)
+	(LEQ! MINCALL CALLCOUNT)
+	(LEQ! (GET! 'MINCALL NAM!) (GET! 'CALLCOUNT NAM!))
+	(OR! (EQ! (NUMBERP! BRKLEVEL))
+	     (EQ! LEVELCOUNT BRKLEVEL) )
+	(OR! (EQ! (NUMBERP! (GET! 'BRKLEVEL NAM!)))
+	     (EQ! (GET! 'LEVELCOUNT NAM!) (GET! 'BRKLEVEL NAM!)))
+	(OR! (EQ! (SETQ! LST! (GET! 'DEBUGIN NAM!)))
+	     (LOOP!
+		((ATOM! LST!) NIL)
+		((ASSOC! (POP! LST!) BTRLIST)) )) )
+      (TERPRI!)
+      (PRINC! "Break-point:  ")
+      (PRTCALL! NAM! ARGLST!)
+      (SETQ! LST! (BREAK!)) ) )
+  ((EQ! (EQ! LST!)))
+  (SETQ! ARGLST! (APPLY! (CAR! (GET! NAM! 'DEBUG)) ARGLST!))
+  (HISTORY! NAM! ARGLST! LEVELCOUNT 'PRTRSLT!)
+  ( ((TRACEP! NAM!)
+      (PRTRSLT! NAM! ARGLST! LEVELCOUNT) ) )
+  ( ((EQ! NAM! (CAR! (CAR! BTRLIST)))
+      (POP! BTRLIST) ) )
+  (PUTSUB! 'LEVELCOUNT NAM!)
+  ARGLST! ))
+
+(DEFUN TRACEP! (NAM!
+     LST!)
+   (AND! TRACE
+	(FLAGP! 'TRACE NAM!)
+	(LEQ! MINCALL CALLCOUNT)
+	(LEQ! MINLEVEL LEVELCOUNT)
+	(LEQ! LEVELCOUNT MAXLEVEL)
+	(LEQ! (GET! 'MINLEVEL NAM!) (GET! 'LEVELCOUNT NAM!))
+	(LEQ! (GET! 'LEVELCOUNT NAM!) (GET! 'MAXLEVEL NAM!))
+	(OR! (EQ! (SETQ! LST! (GET! 'DEBUGIN NAM!)))
+	     (LOOP!
+	       ((ATOM! LST!) NIL)
+	       ((ASSOC! (POP! LST!) BTRLIST)) ) ) ) )
+
+(DEFUN LEQ! (NUM1 NUM2)
+    (OR! (EQ! (NUMBERP! NUM1))
+	(EQ! (NUMBERP! NUM2))
+	(EQ! NUM1 NUM2)
+	(<! NUM1 NUM2) ) )
+
+(DEFUN HISTORY! (NAM LST NUM NAM1)
+  (SETQ! HISTORY (TCONC! HISTORY (LIST! NAM1 NAM LST NUM)))
+  ((<! HISTLEN (LENGTH! (CAR! HISTORY)))
+    (RPLACA! HISTORY (CDR! (CAR! HISTORY))) ) )
+
+(DEFUN PUTADD! (NAM1 NAM2)
+  ((EQ! (NUMBERP! (CAR! NAM1))))
+  (SET! NAM1 (+! (CAR! NAM1) 1))
+  ((NUMBERP! (GET! NAM1 NAM2))
+    (PUT! NAM1 NAM2 (+! (GET! NAM1 NAM2) 1)) )
+  (PUT! NAM1 NAM2 1) )
+
+(DEFUN PUTSUB! (NAM1 NAM2)
+  ((EQ! (NUMBERP! (CAR! NAM1))))
+  ( ((EQ! (CAR! NAM1) 0))
+    (SET! NAM1 (+! (CAR! NAM1) -1)) )
+  ((NUMBERP! (GET NAM1 NAM2))
+    ((<! 0 (GET NAM1 NAM2))
+      ((EQ! (GET NAM1 NAM2) 1)
+        (REMPROP! NAM1 NAM2) )
+      (PUT! NAM1 NAM2 (+! (GET! NAM1 NAM2) -1)) ) ) )
+
+(DEFUN PRTCALL! (NAM LST NUM)
+  (PRTNAM!)
+  (SETQ! NAM (CDR! (GET! NAM 'DEBUG)))
+  (PRINC! '"[")
+  ( ((EQ! NAM)
+      ((ATOM! LST))
+      (LOOP!
+	(PRTEXP! NAM (POP! LST))
+	((ATOM! LST))
+	(PRINC! ", ") ) )
+    ((ATOM! NAM)
+      (PRINC! NAM)
+      (PRINC! ": ")
+      (PRTEXP! NAM LST) )
+    (LOOP!
+      (PRINC! (CAR! NAM))
+      (PRINC! ": ")
+      (PRTEXP! (POP! NAM) (POP! LST))
+      ((ATOM! NAM)
+	((ATOM! LST))
+	(LOOP!
+	  (PRTEXP! NAM (POP! LST))
+	  ((ATOM! LST))
+	  (PRINC! ", ") ) )
+      (PRINC! ", ") ) )
+  (PRINC! '"]")
+  (TERPRI!) )
+
+(DEFUN PRTRSLT! (NAM LST NUM)
+  (PRTNAM!)
+  (PRINC! "= ")
+  (PRTEXP! NAM LST)
+  (TERPRI!) )
+
+(DEFUN PRTNAM! ()
+  ( ((NUMBERP! NUM)
+      (FRESH-LINE)
+      ( ((<! NUM 10)
+          (SPACES! 1) ) )
+      (PRINC! NUM)
+      (PRINC! '"|")
+      (SPACES! NUM) ) )
+  (PRINC! NAM)
+  (SPACES! 1) )
+
+(DEFUN PRTEXP! (NAM EXP)
+  (PRINC! EXP) )
+
+
+(MOVD 'CAR 'CAR!)
+(MOVD 'CDR 'CDR!)
+(MOVD 'ASSOC 'ASSOC!)
+(MOVD 'CONS 'CONS!)
+(MOVD 'LIST 'LIST!)
+(MOVD 'REVERSE 'REVERSE!)
+(MOVD 'RPLACA 'RPLACA!)
+(MOVD 'RPLACD 'RPLACD!)
+(MOVD 'TCONC 'TCONC!)
+(MOVD 'GET 'GET!)
+(MOVD 'PUT 'PUT!)
+(MOVD 'REMPROP 'REMPROP!)
+(MOVD 'FLAGP 'FLAGP!)
+(MOVD 'ATOM 'ATOM!)
+(MOVD 'NUMBERP 'NUMBERP!)
+(MOVD 'EQ 'EQ!)
+(MOVD '< '<!)
+(MOVD 'SET 'SET!)
+(MOVD 'SETQ 'SETQ!)
+(MOVD '+ '+!)
+(MOVD 'LENGTH 'LENGTH!)
+(MOVD 'PRINC 'PRINC!)
+(MOVD 'TERPRI 'TERPRI!)
+(MOVD 'SPACES 'SPACES!)
+(MOVD 'APPLY 'APPLY!)
+(MOVD 'BREAK 'BREAK!)
+(MOVD 'LOOP 'LOOP!)
+(MOVD 'AND 'AND!)
+(MOVD 'OR 'OR!)
+(MOVD 'POP 'POP!)
+(MOVD 'PUSH 'PUSH!)
+
+(CLEAR)
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/DOCTOR.LSP b/Microsoft muLISP-86 v51/DOCTOR.LSP
new file mode 100644
index 0000000..7fdd526
--- /dev/null
+++ b/Microsoft muLISP-86 v51/DOCTOR.LSP	
@@ -0,0 +1,956 @@
+;File:  DOCTOR.LSP		12/27/85	Soft Warehouse, Inc.
+
+
+(PROGN
+  (TERPRI 2)
+  (PRINC "Please relax while the Doctor is reviewing your records.")
+  (TERPRI)
+  (PRINC "He will be ready to talk to you in just a few seconds.")
+  (TERPRI 2)
+  (PRINC "            - the Doctor's secretary")
+  (TERPRI 2)
+  (LOOP (PRINC '*) (EVAL (READ)) ((NULL RDS)) ) )
+
+
+(DEFUN DOCTOR (FILE
+    SENTENCE KEYSTACK MEMSTACK FLIPFLOP CTR)
+  ( ((NULL FILE))
+    (WRS (CAR FILE) (CADR FILE) (CADDR FILE))
+    (SETQ ECHO T) )
+  (TERPRI 2)
+  (PRINC "D:  I am at your service; just tell me anything that troubles")
+  (TERPRI)
+  (PRINC "    or concerns you.  Please end your sentences with a period,")
+  (TERPRI)
+  (PRINC "    a question mark, or an exclamation mark, and then press the")
+  (TERPRI)
+  (PRINC "    RETURN or ENTER key.  When you are ready to quit our session,")
+  (TERPRI)
+  (PRINC "    just enter \"GOODBYE.\" and press the RETURN or ENTER key.")
+  (TERPRI 2)
+  (SETNONE)
+  (LOOP
+    (PRINC '"P:  ")
+    (SETQ SENTENCE (MAKSEN (READSENT)))
+    (SETQ KEYSTACK (CDR SENTENCE))
+    (SETQ SENTENCE (CAR SENTENCE))
+    (TERPRI)
+    (PRINC '"D:  ")
+    ((MEMBER 'GOODBYE SENTENCE))
+    (SETQ CTR 800)
+    (LOOP ((ZEROP (DECQ CTR))))		;An optional short pause
+    (PRTSENT (ANALYZE))
+    (TERPRI)
+    (MEMORY) )
+  (PRINC "I hope I have been of some service, let's get together")
+  (TERPRI)
+  (PRINC "    again sometime.")
+  (TERPRI)
+  '"" )
+
+
+(DEFUN MAKSEN (SENTENCE WORD FLAG RULE KEYSTACK)
+  (SETQ KEYSTACK (CONS))
+  (LOOP
+    ((NULL SENTENCE)
+      (CONS (REVERSE RULE) KEYSTACK) )
+    (SETQ WORD (CAR SENTENCE))
+    ( ((NUMBERP WORD)
+	(SETQ WORD (COND
+	  ((ZEROP WORD) ZERO)
+	  ((EQ WORD 1) ONE)
+	  ((EQ WORD 2) TWO)
+	  (NUMBER) )) ) )
+    ((MEMBER WORD PCTLIS)
+      (SETQ FLAG (MAKSEN (CDR SENTENCE)))
+      ((NULL (CDR KEYSTACK)) FLAG)
+      ((AND (CDDR FLAG) (NOT (>
+	  (GETP (CDR KEYSTACK) 'PRIORITY)
+	  (GETP (CDDR FLAG) 'PRIORITY) )))
+	FLAG )
+      (CONS (REVERSE RULE) KEYSTACK) )
+    ( ((GETP WORD 'MEMR)
+	(SETQ MEMSTACK (APPEND (GETP WORD 'MEMR) MEMSTACK)) ) )
+    ( ((GETP WORD 'PRIORITY)
+	((AND (CDR KEYSTACK) (> (GETP WORD 'PRIORITY)
+	    (GETP (CDR KEYSTACK) 'PRIORITY) ))
+	  (RPLACD KEYSTACK (CONS (CDR KEYSTACK) (CDR WORD))) )
+	(BCONC (CDR WORD) KEYSTACK) ) )
+    (SETQ WORD (COND
+	((GETP WORD 'TRANSLATION))
+	(WORD) ))
+    (PUSH WORD RULE)
+    (POP SENTENCE) ) )
+
+(DEFUN ANALYZE (RULES PARSLST CR EXIT)
+  (SETQ FLIPFLOP (NOT FLIPFLOP))
+  (BCONC (GETP 'NONE (COND
+      ((NULL FLIPFLOP)
+	'MEM )
+      ('LASTRESORT) ))
+    KEYSTACK )
+  (POP KEYSTACK)
+  (SETQ RULES (GETP KEYSTACK 'RULES))
+  (LOOP
+    (SETQ EXIT NIL)
+    ( ((OR (NULL RULES) (EQ (CAR RULES) 'NEWKEY))
+	(SETQ KEYSTACK (CAR KEYSTACK))
+	(SETQ RULES (GETP KEYSTACK 'RULES)) )
+      ((ATOM (CAR RULES))
+	(SETQ RULES (GETP (CAR RULES) 'RULES)) )
+      (SETQ PARSLST (CONS))
+      ((NOT (TEST (CAAR RULES) SENTENCE))
+	(POP RULES) )
+      (SETQ RULES (CAR (ADVANCE RULES)))
+      (SETQ CR (CAR RULES))
+      ((ATOM CR))
+      ((EQ (CAR CR) 'PRE)
+	(SETQ SENTENCE (RECONSTRUCT (CADR CR) PARSLST))
+	(SETQ RULES (CDDR CR)) )
+      (SETQ EXIT T) )
+    ((EVAL EXIT)
+      (RECONSTRUCT CR PARSLST) ) ) )
+
+(DEFUN MEMORY (PARSLST X)
+  (LOOP
+    ((NULL MEMSTACK))
+    (SETQ PARSLST (CONS))
+    ( ((TEST (CAAR MEMSTACK) SENTENCE)
+	(SETQ X (CDAR (CADR (GETP 'NONE 'MEM))))
+	(RPLACA X (CONS (CAR X) (CONS
+	  (RECONSTRUCT (CAAR (ADVANCE MEMSTACK)) PARSLST)
+	  (CDAR X) ))) ) )
+    (POP MEMSTACK) ) )
+
+(DEFUN ADVANCE (RULES)
+  (RPLACA (CDAR RULES) (COND
+    ((NULL (CDAR (CDAR RULES)))
+      (CDDAR RULES) )
+    ((CDAR (CDAR RULES))) )) )
+
+(DEFUN RECONSTRUCT (RULE PARSLST WORD SENTENCE V1)
+  (LOOP
+    ((NULL RULE)
+      (REVERSE SENTENCE) )
+    (SETQ WORD (CAR RULE))
+    ( ((NUMBERP WORD)
+	(SETQ WORD (DOCNTH PARSLST WORD))
+	(SETQ V1 (CAR WORD))
+	(LOOP
+	  ((EQ V1 (CADR WORD)))
+	  (PUSH (POP V1) SENTENCE) ) )
+      (PUSH WORD SENTENCE) )
+    (POP RULE) ) )
+
+(DEFUN TEST (D S CD PSV)
+  (SETQ PSV (CDR PARSLST))
+  (LOOP
+    ((NULL D)
+      ((NOT S)
+	(SETQ PARSLST (CAR PARSLST))
+	T )
+      (RN) )
+    (SETQ CD (CAR D))
+    ((ZEROP CD)
+      (TCONC PARSLST S)
+      (POP D)
+      ((NULL D)
+	(SETQ PARSLST (CAR PARSLST))
+	T )
+      (LOOP
+	((TEST D S) T)
+	(POP S)
+	((NULL S)
+	  (RN) ) ) )
+    ((NOT (RNP))
+      (RN) )
+    (POP S)
+    (POP D) ) )
+
+(DEFUN RN ()
+  (RPLACD PARSLST (COND
+    ((NOT PSV) NIL)
+    ((RPLACD PSV NIL)) )) NIL)
+
+(DEFUN RNP ()
+  ((NULL S) NIL)
+  ((NUMBERP CD)
+    (TCONC PARSLST S)
+    (SETQ S (DOCNTH S CD)) )
+  ((COND
+    ((ATOM CD)
+      (EQ CD (CAR S)) )
+    ((CAR CD)
+      (MEMBER (CAR S) CD) )
+    ((TEST4 (CAR S) (CDR CD))) )
+      (TCONC PARSLST S) T ) )
+
+(DEFUN TEST4 (CS L)
+  (LOOP
+    ((GETP CS (POP L)))
+    ((NULL L) NIL) ) )
+
+(DEFUN BCONC (X Y)
+  (SETQ X (CONS NIL X))
+  ((NULL Y)
+    (CONS X X) )
+  ((NULL (CAR Y))
+    (RPLACD Y X)
+    (RPLACA Y X) )
+  (RPLACA (CAR Y) X)
+  (RPLACA Y (CAAR Y)) )
+
+(DEFUN GETP (X Y)
+  (LOOP
+    (SETQ X (CDR X))
+    ((NULL X) NIL)
+    ((EQ (CAR X) Y)
+      (CADR X) )
+    (POP X) ) )
+
+(DEFUN PUTP (X Y Z XX)
+  (SETQ XX X)
+  (LOOP
+    ((NULL (CDR X))
+      (RPLACD X (LIST Y Z)) )
+    ((EQ (CADR X) Y)
+      (RPLACA (CDDR X) Z) )
+    (SETQ X (CDDR X))
+    ((NULL X)
+      (RPLACD XX (LIST* Y Z (CDR XX))) ) )
+  Z )
+
+(SETQ XXXX 'XXXX)
+
+(DEFUN SETNONE (A)
+  (SETQ A XXXX)
+  (RPLACD A (GETP 'NONE 'LASTRESORT))
+  (PUTP 'NONE 'MEM (LIST 'RULES (LIST (LIST (LIST 0) (CONS) A))) ) )
+
+(DEFUN DOCNTH (X Y)
+  ((ZEROP Y)
+    (CONS NIL X) )
+  (LOOP
+    (DECQ Y)
+    ((ZEROP Y) X)
+    (POP X) ) )
+
+(DEFUN RPLQQ (NLAMBDA ARG
+  (RPLACD (CAR ARG) (CDR ARG))
+  (CAR ARG) ))
+
+; * * *   C O N S O L E   I N T E R F A C E   R O U T I N E S   * * *
+
+(DEFUN READSENT (SENTENCE
+    WORD )
+  (LOOP
+    (SETQ WORD (STRING-UPCASE (RATOM)))
+    ((MEMBER WORD TRMLIS)
+      (REVERSE SENTENCE) )
+    ( ((MEMBER WORD SEPLIS)
+	(PUSH (PACK* (POP SENTENCE) WORD (STRING-UPCASE (RATOM))) SENTENCE) )
+      (PUSH WORD SENTENCE) ) ) )
+
+(DEFUN PRTSENT (SENTENCE
+    WORD *PRINT-DOWNCASE* )
+  (SETQ *PRINT-DOWNCASE* T)
+  (PRTCAP (POP SENTENCE))
+  (LOOP
+    ((NULL SENTENCE)
+      (PRINC '?) )
+    (SETQ WORD (POP SENTENCE))
+    ((MEMBER WORD TRMLIS)
+      (PRINC WORD) )
+    ( ((OR (NULL SENTENCE) (MEMBER (CAR SENTENCE) TRMLIS)
+	(MEMBER (CAR SENTENCE) PCTLIS) )
+	  (PRETERPRI WORD) ) )
+    ( ((MEMBER WORD PCTLIS))
+      (SPACES 1) )
+    ( ((MEMBER WORD CAPLIS)
+	(PRTCAP WORD) )
+      (PRINC WORD) ) ) )
+
+(DEFUN PRTCAP (WORD)
+  ((NUMBERP WORD)
+    (PRINC WORD) )
+  (PRETERPRI WORD)
+  (SETQ WORD (UNPACK WORD))
+  (SETQ *PRINT-DOWNCASE*)  (PRINC (CAR WORD))  (SETQ *PRINT-DOWNCASE* T)
+  (LOOP
+    (POP WORD)
+    ((NULL WORD))
+    (PRINC (CAR WORD)) ) )
+
+(DEFUN PRETERPRI (WORD)
+  ((> (+ (SPACES) (LENGTH WORD)) (LINELENGTH))
+    (TERPRI) ) )
+
+(SETQ CAPLIS '(I HAWAII))
+(SETQ TRMLIS '("." ! ?))
+(SETQ PCTLIS '("," ";" "(" ")" ":"))
+(SETQ SEPLIS '("'" "-"))
+
+
+; The remainder of this file is the script for the DOCTOR program.
+
+(RPLQQ NONE LASTRESORT (RULES (
+      ((0)
+	(NIL)
+	(I AM NOT SURE I UNDERSTAND YOU FULLY ".")
+	(PLEASE GO ON ".")
+	(WHAT DOES THAT SUGGEST TO YOU)
+	(WHAT ELSE WOULD YOU LIKE TO DISCUSS)
+	(WHY DO YOU SAY THAT JUST NOW) ) )))
+
+(RPLQQ SORRY PRIORITY 2 RULES (
+      ((0)
+	(NIL)
+	(PLEASE "DON'T" APOLOGIZE ".")
+	(APOLOGIES ARE NOT NECESSARY ".")
+	(WHAT FEELINGS DO YOU HAVE WHEN YOU APOLOGIZE) ) ))
+
+(RPLQQ DONT TRANSLATION "DON'T")
+
+(RPLQQ CANT TRANSLATION "CAN'T")
+
+(RPLQQ WONT TRANSLATION "WON'T")
+
+(RPLQQ REMEMBER PRIORITY 5 RULES (
+      ((REMEMBER 0)
+	  (NIL)
+	  (PRE (DO I REMEMBER 2) REMEMBER) )
+      ((YOU REMEMBER 0)
+	(NIL)
+	(DO YOU OFTEN THINK OF 3)
+	(WHAT ELSE DOES THINKING OF 3 BRING TO MIND)
+	(WHAT ELSE DO YOU REMEMBER)
+	(WHY DO YOU REMEMBER 3 JUST NOW)
+	(WHAT IN THE PRESENT SITUATION REMINDS YOU OF 3)
+	(WHAT IS THE CONNECTION BETWEEN ME AND 3) )
+      ((DO I REMEMBER 0)
+	(NIL)
+	(WHY DID YOU THINK I WOULD FORGET 4)
+	(WHY DO YOU THINK I SHOULD RECALL 4 NOW)
+	(WHAT ABOUT 4)
+	WHAT
+	(YOU MENTIONED 4) )
+      ((0)
+	(NIL)
+	NEWKEY ) ))
+
+(RPLQQ IF PRIORITY 3 RULES (
+      ((0 IF 0 HAD 0)
+	(NIL)
+	(PRE (1 2 3 MIGHT HAVE 5) IF) )
+      ((0 IF 0)
+	(NIL)
+	(DO YOU THINK ITS LIKELY THAT 3)
+	(DO YOU WISH THAT 3)
+	(WHAT DO YOU THINK ABOUT 3)
+	("REALLY," IF 3) ) ))
+
+(RPLQQ DREAMT PRIORITY 4 RULES (
+      ((0 YOU DREAMT 0)
+	(NIL)
+	(REALLY 4)
+	(HAVE YOU EVER FANTASIZED 4 WHILE YOU WERE AWAKE)
+	(HAVE YOU DREAMT 4 BEFORE)
+	DREAM
+	NEWKEY)
+      ((0) (NIL) DREAM NEWKEY) ))
+
+(RPLQQ DREAMED TRANSLATION DREAMT PRIORITY 4 RULES (DREAMT))
+
+(RPLQQ DREAM PRIORITY 3 RULES (
+      ((0 YOU DREAM (OF ABOUT) 0)
+	(NIL)
+	(WHAT MIGHT 5 REPRESENT)
+	(WHAT DOES 5 SUGGEST TO YOU)
+	(HOW DOES THAT DREAM RELATE TO YOUR PROBLEM) )
+      ((0)
+	(NIL)
+	(WHAT DOES THAT DREAM SUGGEST TO YOU)
+	(WHAT DO YOU DREAM ABOUT)
+	(WHAT PERSONS APPEAR IN YOUR DREAMS)
+	(WOULD YOU LIKE TO FLEE FROM REALITY)
+	NEWKEY ) ))
+
+(RPLQQ DREAMS TRANSLATION DREAM PRIORITY 3 RULES (DREAM))
+
+(RPLQQ HOW RULES (WHAT) PRIORITY 0)
+
+(RPLQQ WHEN PRIORITY 0 RULES (
+      ((WHEN (DO DID DOES WILL) 0)
+	(NIL)
+	XXWHAT )
+      ((0)
+	(NIL)
+	(IS THERE ANY OTHER TIME)
+	(WHY "THEN," DO YOU SUPPOSE) ) ))
+
+(RPLQQ ALIKE PRIORITY 10 RULES (DIT))
+
+(RPLQQ SAME PRIORITY 3 RULES (DIT))
+
+(RPLQQ CERTAINLY PRIORITY 0 RULES (YES))
+
+(RPLQQ FEEL BELIEF T)
+
+(RPLQQ THINK BELIEF T)
+
+(RPLQQ BELIEVE BELIEF T)
+
+(RPLQQ WISH BELIEF T)
+
+(RPLQQ BET BELIEF T)
+
+(RPLQQ MY MEMR (
+      ((YOUR 2 0)
+	(NIL)
+	("LET'S" DISCUSS FURTHER WHY YOUR 2 3 ".")
+	(EARLIER YOU SAID YOUR 2 3 ".")
+	(BUT YOUR 2 3 ".")
+	(DOES THAT HAVE ANYTHING TO DO WITH THE FACT THAT YOUR 2 3) )
+      ((0 YOUR 1 0)
+	(NIL)
+	(EARLIER YOU SAID YOUR 3 4)
+	(BUT YOUR 3 4)
+	(DOES THAT HAVE ANYTHING TO DO WITH YOUR 3 4) )
+      ((0 YOUR 1)
+	(NIL)
+	(WOULD YOU LIKE TO DISCUSS YOUR 3)
+	(PERHAPS THAT CONCERNS YOUR 3 ".")
+	(TELL ME MORE ABOUT YOUR 3 ".") ) )
+
+    PRIORITY 0 TRANSLATION YOUR RULES (
+      ((0 YOUR 0 (NIL FAMILY) 0)
+	(NIL)
+	(TELL ME MORE ABOUT YOUR FAMILY ".")
+	(WHO ELSE IN YOUR FAMILY 5)
+	(YOUR 4)
+	(WHAT ELSE COMES TO MIND WHEN YOU THINK OF YOUR 4) )
+      ((YOUR 2 0)
+	(NIL)
+	(IS IT IMPORTANT TO YOU THAT YOUR 2 3)
+	(DO YOU SUPPOSE ANYONE "ELSE'S" 2 3)
+	(WHAT MAKES YOU THINK YOUR 2 3)
+	(SUPPOSE I "DIDN'T" BELIEVE THAT YOUR 2 3 ".") )
+      ((0 YOUR 1)
+	(NIL)
+	(YOUR 3)
+	(WHY DO YOU SAY YOUR 3)
+	(WHO ELSE KNOWS ABOUT YOUR 3)
+	(WHY DO YOU MENTION YOUR 3 JUST NOW)
+	(WHY IS YOUR 3 IMPORTANT TO YOU)
+	(DO YOU OFTEN DISCUSS YOUR 3) ) ))
+
+(RPLQQ PERHAPS PRIORITY 0 RULES (
+      ((0)
+	(NIL)
+	(YOU "DON'T" SEEM QUITE CERTAIN ".")
+	(WHY THE UNCERTAIN TONE)
+	("CAN'T" YOU BE MORE POSITIVE)
+	(YOU "AREN'T" SURE)
+	("DON'T" YOU KNOW) ) ))
+
+(RPLQQ MAYBE PRIORITY 0 RULES (PERHAPS))
+
+(RPLQQ NAME PRIORITY 15 RULES (
+      ((0)
+	(NIL)
+	(I AM NOT INTERESTED IN NAMES ".")
+	("I'VE" TOLD YOU BEFORE I "DON'T" CARE ABOUT
+		NAMES - PLEASE CONTINUE ".") ) ))
+
+(RPLQQ DEUTSCH PRIORITY 0 RULES (
+      ((0)
+	(NIL)
+	(I AM "SORRY," I SPEAK ONLY ENGLISH) ) ))
+
+(RPLQQ FRANCAIS PRIORITY 0 RULES (DEUTSCH))
+
+(RPLQQ SVENSKA PRIORITY 0 RULES (DEUTSCH))
+
+(RPLQQ ITALIANO PRIORITY 0 RULES (DEUTSCH))
+
+(RPLQQ ESPANOL PRIORITY 0 RULES (DEUTSCH))
+
+(RPLQQ HELLO PRIORITY 0 RULES (
+      ((0)
+	(NIL)
+	("HI," HOW ARE YOU) ) ))
+
+(RPLQQ COMPUTER PRIORITY 8 RULES (
+      ((0)
+	(NIL)
+	(DO COMPUTERS WORRY YOU)
+	(WHY DO YOU MENTION COMPUTERS)
+	(WHAT DO YOU THINK MACHINES HAVE TO DO WITH YOUR PROBLEM)
+	("DON'T" YOU THINK COMPUTERS CAN HELP PEOPLE) ) ))
+
+(RPLQQ MACHINE PRIORITY 8 RULES (COMPUTER))
+
+(RPLQQ MACHINES PRIORITY 8 RULES (COMPUTER))
+
+(RPLQQ COMPUTERS PRIORITY 10 RULES (COMPUTER))
+
+(RPLQQ AM PRIORITY 0 TRANSLATION ARE RULES (
+      ((ARE YOU 0)
+	(NIL)
+	(DO YOU BELIEVE YOU ARE 3)
+	(WOULD YOU WANT TO BE 3)
+	(YOU WISH I WOULD TELL YOU YOU ARE 3 ".")
+	(WHAT WOULD IT MEAN IF YOU WERE 3)
+	XXWHAT )
+      ((0)
+	(NIL)
+	(WHY DO YOU SAY "'AM'")
+	(I "DON'T" UNDERSTAND THAT) ) ))
+
+(RPLQQ ARE PRIORITY 0 RULES (
+      ((THERE (ARE IS) (NO NOT) 0)
+	(NIL)
+	(WHAT IF THERE WERE 4)
+	(DID YOU THINK THERE MIGHT BE 4)
+	(PRE (THERE 2 4) ARE) )
+      ((THERE (ARE IS) 0)
+	(NIL)
+	(2 THERE REALLY 3)
+	(WHY 2 THERE 3)
+	(HOW 3 THE 4 RELATED TO YOU) )
+      ((ARE I 0)
+	(NIL)
+	(WHY ARE YOU INTERESTED IN WHETHER I AM 3 OR NOT)
+	(WOULD YOU PREFER IF I "WEREN'T" 3)
+	(PERHAPS I AM 3 IN YOUR FANTASIES ".")
+	(DO YOU SOMETIMES THINK I AM 3)
+	XXWHAT )
+      ((ARE 0)
+	(NIL)
+	XXWHAT )
+      ((0 1 (ARE IS) NOT 0)
+	(NIL)
+	(POSSIBLY THAT IS FOR THE BETTER ".")
+	(WHAT IF 2 WERE 5)
+	(WHAT DO YOU REALLY KNOW ABOUT 2))
+      ((0 (ARE IS) 0)
+	(NIL)
+	(SUPPOSE 1 WERE NOT 3 ".")
+	(POSSIBLY 1 REALLY 2 NOT 3 ".")
+	(TELL ME MORE ABOUT 1 ".")
+	(DID YOU THINK 1 MIGHT NOT BE 3)
+	(1 PERHAPS 2 3 ".") ) ))
+
+(RPLQQ YOUR PRIORITY 0 TRANSLATION MY RULES (
+      ((0 MY 1)
+	(NIL)
+	(WHY ARE YOU CONCERNED OVER MY 3)
+	(WHAT ABOUT YOUR OWN 3)
+	(ARE YOU WORRIED ABOUT SOMEONE "ELSE'S" 3)
+	("REALLY," MY 3))
+      ((MY 0)
+	(NIL)
+	(PERHAPS YOUR OWN 2 ".")
+	(ARE YOU WORRIED THAT MY 2) ) ))
+
+(RPLQQ WAS PRIORITY 2 RULES (
+      ((WAS YOU 0)
+	(NIL)
+	(WHAT IF YOU WERE 3)
+	(DO YOU THINK YOU WERE 3)
+	(WERE YOU 3)
+	(WHAT WOULD IT MEAN IF YOU WERE 3)
+	XXWHAT)
+      ((YOU WAS 0)
+	(NIL)
+	(WERE YOU REALLY)
+	(WHY DO YOU TELL ME YOU WERE 3 NOW)
+	(PERHAPS I ALREADY KNEW YOU WERE 3 "."))
+      ((WAS I 0)
+	(NIL)
+	(WOULD YOU LIKE TO BELIEVE I WAS 3)
+	(WHAT SUGGESTS THAT I WAS 3)
+	(WHAT DO YOU THINK)
+	(PERHAPS I WAS 3 ".")
+	(WHAT IF I HAD BEEN 3) ) ))
+
+(RPLQQ WERE PRIORITY 0 TRANSLATION WAS RULES (WAS))
+
+(RPLQQ ME TRANSLATION YOU)
+
+(RPLQQ "YOU'RE" PRIORITY 0 TRANSLATION "I'M" RULES (
+      ((0 "I'M" 0)
+	(NIL)
+	(PRE (I ARE 3) YOU) ) ))
+
+(RPLQQ "I'M" PRIORITY 0 TRANSLATION "YOU'RE" RULES (
+      ((0 "YOU'RE" 0)
+	(NIL)
+	(PRE (YOU ARE 3) I) ) ))
+
+(RPLQQ MYSELF TRANSLATION YOURSELF)
+
+(RPLQQ YOURSELF TRANSLATION MYSELF)
+
+(RPLQQ MOTHER FAMILY T)
+
+(RPLQQ MOM TRANSLATION MOTHER FAMILY T)
+
+(RPLQQ DAD TRANSLATION FATHER FAMILY T)
+
+(RPLQQ FATHER FAMILY T)
+
+(RPLQQ SISTER FAMILY T)
+
+(RPLQQ BROTHER FAMILY T)
+
+(RPLQQ WIFE FAMILY T)
+
+(RPLQQ CHILDREN FAMILY T)
+
+(RPLQQ I PRIORITY 0 TRANSLATION YOU RULES (
+      ((0 YOU (WANT NEED) 0)
+	(NIL)
+	(WHAT WOULD IT MEAN TO YOU IF YOU GOT 4)
+	(WHY DO YOU WANT 4)
+	(WHAT WOULD GETTING 4 MEAN TO YOU))
+      ((0 YOU ARE 0 (SAD UNHAPPY DEPRESSED SICK ILL) 0)
+	(NIL)
+	(I AM SORRY TO HEAR YOU ARE 5 ".")
+	(DO YOU THINK COMING HERE WILL HELP YOU NOT TO BE 5)
+	(CAN YOU EXPLAIN WHAT MADE YOU 5))
+      ((0 YOU ARE 0 (HAPPY ELATED GLAD BETTER) 0)
+	(NIL)
+	(HOW HAVE I HELPED YOU TO BE 5)
+	(HAS YOUR TREATMENT MADE YOU 5)
+	(WHAT MAKES YOU 5 JUST NOW))
+      ((0 YOU (NIL BELIEF) YOU 0)
+	(NIL)
+	(DO YOU REALLY THINK SO)
+	(BUT YOU ARE NOT SURE YOU 5)
+	(DO YOU REALLY DOUBT YOU 5))
+      ((0 YOU 0 (NIL BELIEF) 0 I 0)
+	(NIL)
+	(PRE (6 7) YOU))
+      ((0 YOU ARE 0)
+	(NIL)
+	(IS IT BECAUSE YOU ARE 4 THAT YOU CAME TO ME)
+	(HOW LONG HAVE YOU BEEN 4)
+	(DO YOU BELIEVE IT NORMAL TO BE 4)
+	(DO YOU ENJOY BEING 4))
+      ((0 YOU ("CAN'T" CANNOT) 0)
+	(NIL)
+	(HOW DO YOU KNOW YOU "CAN'T" 4)
+	(HAVE YOU TRIED)
+	(PERHAPS YOU COULD 4 NOW ".")
+	(DO YOU REALLY WANT TO BE ABLE TO 4))
+      ((0 YOU ("DON'T" "WON'T") 0)
+	(NIL)
+	("DON'T" YOU REALLY 4)
+	(WHY "DON'T" YOU 4)
+	(DO YOU WISH YOU DID 4)
+	(DOES THAT TROUBLE YOU))
+      ((0 YOU FEEL 0)
+	(NIL)
+	(TELL ME MORE ABOUT SUCH FEELINGS ".")
+	(DO YOU OFTEN FEEL 4)
+	(DO YOU ENJOY FEELING 4)
+	(OF WHAT DOES FEELING 4 REMIND YOU))
+      ((YOU 0 I)
+	(NIL)
+	(PERHAPS IN YOUR FANTASY WE 2 EACH OTHER ".")
+	(DO YOU WISH TO 2 ME)
+	(YOU SEEM TO NEED TO 2 ME ".")
+	(DO YOU 2 ANYONE ELSE))
+      ((0 YOU (NIL EMOTION) 0)
+	(NIL)
+	(WHAT ELSE DO YOU 3)
+	(TELL ME MORE ABOUT 4 ".")
+	(WHY DO YOU 3 4)
+	(I DOUBT THAT YOU REALLY 3 4 "."))
+      ((0 YOU 1 0)
+	(NIL)
+	(YOU SAY 2 3 4)
+	(CAN YOU ELABORATE ON THAT)
+	(DO YOU SAY 2 3 4 FOR SOME SPECIAL REASON)
+	(TELL ME MORE ABOUT YOURSELF ".")
+	(OH? 2 3 4)
+	("THAT'S" QUITE INTERESTING ".")))
+    MEMR (
+      ((0 YOU ARE 0)
+	(NIL)
+	(ARE YOU STILL 4)
+	(EARLIER YOU SAID YOU WERE 4 ".")
+	(MAYBE NOW WE CAN DISCUSS WHY YOU ARE 4 ".")
+	(DID YOU TELL ME YOU WERE 4))))
+
+(RPLQQ YOU PRIORITY 0 TRANSLATION I RULES (
+      ((0 I REMIND YOU OF 0)
+	(NIL)
+	DIT)
+      ((0 I ARE 0)
+	(NIL)
+	(WHAT MAKES YOU THINK I AM 4)
+	(DOES IT PLEASE YOU TO BELIEVE I AM 4)
+	(PERHAPS YOU WOULD LIKE TO BE 4 ".")
+	(DO YOU SOMETIMES WISH YOU WERE 4))
+      ((0 I 0 YOU)
+	(NIL)
+	(WHY DO YOU THINK I 3 YOU)
+	(YOU LIKE TO THINK I 3 YOU - "DON'T" YOU)
+	(WHAT MAKES YOU THINK I 3 YOU)
+	(REALLY? I 3 YOU)
+	(DO YOU WISH TO BELIEVE I 3 YOU)
+	(SUPPOSE I DID 3 YOU - WHAT WOULD THAT MEAN)
+	(DOES SOMEONE ELSE BELIEVE I 3 YOU))
+      ((0 I 1 0)
+	(NIL)
+	(SUPPOSE YOU 3 4 ".")
+	(OH? I 3 4)
+	(WHAT MAKES YOU THINK I 3 4)
+	(WHO ARE YOU REALLY TALKING ABOUT))))
+
+(RPLQQ XXYYZZ RULES (
+      ((0)
+	(NIL)
+	(IS THERE SOMETHING BOTHERING YOU)
+	(CAN YOU BE MORE INFORMATIVE)
+	(PERHAPS YOU WOULD RATHER TALK ABOUT SOMETHING ELSE ".")
+	(PLEASE TELL ME MORE "."))))
+
+(RPLQQ YES PRIORITY -1 RULES (
+      ((0) (NIL)
+	XXYYZZ
+	(WHY ARE YOU SO SURE)
+	(I SEE ".")
+	(I UNDERSTAND "."))))
+
+(RPLQQ NO PRIORITY -1 RULES (
+      ((0 NO (BODY ONE) 0)
+	(NIL)
+	NOBODY)
+      ((0)
+	(NIL)
+	XXYYZZ
+	(VERY WELL ".")
+	(WHY NOT)
+	(WHY "'NO'") NEWKEY)))
+
+(RPLQQ CAN PRIORITY 0 RULES (
+      ((CAN I 0)
+	(NIL)
+	(YOU BELIEVE I CAN 3 "DON'T" YOU)
+	XXWHAT
+	(YOU WANT ME TO BE ABLE TO 3 ".")
+	(PERHAPS YOU WOULD LIKE TO BE ABLE TO 3 YOURSELF "."))
+      ((CAN YOU 0)
+	(NIL)
+	(WHETHER OR NOT YOU CAN 3 DEPENDS ON YOU MORE THAN ON ME ".")
+	(DO YOU WANT TO BE ABLE TO 3)
+	(PERHAPS YOU "DON'T" WANT TO 3 ".")
+	XXWHAT)))
+
+(RPLQQ IS PRIORITY 0 RULES (
+      ((IS 0)
+	(NIL)
+	XXWHAT )
+      ARE ))
+
+(RPLQQ WHERE PRIORITY 0 RULES (WHAT))
+
+(RPLQQ WHAT PRIORITY 0 RULES (
+      (((HOW WHERE WHAT WHY) 0)
+	(NIL)
+	XXWHAT)))
+
+(RPLQQ XXWHAT RULES (
+      ((0)
+	(NIL)
+	(WHY DO YOU ASK)
+	(WHY DOES THAT QUESTION INTEREST YOU)
+	(WHY ARE SUCH QUESTIONS ON YOUR MIND)
+	(WHAT ANSWER WOULD PLEASE YOU MOST)
+	(WHAT DO YOU THINK)
+	(WHEN HAVE YOU ASKED SUCH QUESTIONS BEFORE)
+	(WHO ELSE HAVE YOU ASKED))))
+
+(RPLQQ BECAUSE PRIORITY 0 RULES (
+      ((0)
+	(NIL)
+	(IS THAT THE REAL REASON)
+	(I SEE ".")
+	("DON'T" ANY OTHER REASONS COME TO MIND)
+	(DOES THAT REASON SEEM TO EXPLAIN ANYTHING ELSE)
+	(AND WHAT DOES THAT SUGGEST)
+	(WHAT OTHER REASONS MIGHT THERE BE))))
+
+(RPLQQ WHY PRIORITY 0 RULES (
+      ((0 WHY ("DON'T" "WON'T") I 0)
+	(NIL)
+	(DO YOU BELIEVE I "DON'T" 5)
+	(PERHAPS I WILL 5 IN GOOD TIME ".")
+	(SHOULD YOU 5 YOURSELF)
+	(YOU WANT ME TO 5 ".")
+	WHAT)
+      ((0 WHY "CAN'T" YOU 0)
+	(NIL)
+	(DO YOU THINK YOU SHOULD BE ABLE TO 5)
+	(DO YOU WANT TO BE ABLE TO 5)
+	(DO YOU BELIEVE THIS WILL HELP YOU TO 5)
+	(HAVE YOU ANY IDEA WHY YOU "CAN'T" 5)
+	WHAT )
+      WHAT))
+
+(RPLQQ EVERYONE PRIORITY 2 RULES (
+      ((0)
+	(NIL)
+	(CAN YOU THINK OF ANYONE IN PARTICULAR)
+	("WHO," FOR EXAMPLE)
+	(YOU ARE THINKING OF A VERY SPECIAL PERSON ".")
+	(YOU HAVE A PARTICULAR PERSON IN "MIND," "DON'T" YOU) ) ))
+
+(RPLQQ EVERYBODY PRIORITY 2 RULES (EVERYONE))
+
+(RPLQQ NOBODY PRIORITY 2 RULES (
+      ((0)
+	(NIL)
+	(SURELY "SOMEONE...")
+	(PERHAPS YOU JUST "DON'T" KNOW OF ANYONE "."))))
+
+(RPLQQ NO-ONE PRIORITY 2 RULES (NOBODY))
+
+(RPLQQ ALWAYS PRIORITY 1 RULES (
+      ((0)
+	(NIL)
+	(CAN YOU THINK OF A SPECIFIC EXAMPLE)
+	(WHEN)
+	(WHAT INCIDENT ARE YOU THINKING OF)
+	("REALLY," ALWAYS) ) ))
+
+(RPLQQ LIKE RULES (
+      ((0 (AM IS ARE WAS) 0 LIKE 0)
+	(NIL)
+	DIT) )
+      EMOTION T PRIORITY 3)
+
+(RPLQQ DIT RULES (
+      ((0)
+	(NIL)
+	(IN WHAT WAY)
+	(WHAT RESEMBLANCE DO YOU SEE)
+	(WHAT DOES THAT SIMILARITY SUGGEST TO YOU)
+	(WHAT OTHER CONNECTIONS DO YOU SEE)
+	(WHAT IS THE "CONNECTION," DO YOU SUPPOSE)
+	(HOW) ) ))
+
+(RPLQQ OH PRIORITY 10 RULES (
+      ((0 YOUR OH YOUR 0)
+	(NIL)
+	(PRE (1 MY-OH-MY 5) NEWKEY) )
+      ((0 OH YOUR 0)
+	(NIL)
+	(PRE (1 OH-MY 4) NEWKEY) ) ))
+
+(RPLQQ EVERY PRIORITY 0 RULES (
+      ((0 EVERY (ONE BODY) 0)
+	(NIL)
+	EVERYONE )
+      ((0 EVERY TIME 0)
+	(NIL)
+	ALWAYS ) ))
+
+(RPLQQ DO PRIORITY 0 RULES (
+      ((DO I 0)
+	(NIL)
+	(PRE (I 3) YOU)
+	XXWHAT)
+      ((DO YOU 0)
+	(NIL)
+	(PRE (YOU 3) I)
+	XXWHAT) ))
+
+(RPLQQ GIRLS PRIORITY 3 RULES (
+      ((0 (GIRLS WOMEN) 0)
+	(NIL)
+	(PRE (1 2 S 3) BOY) ) ))
+
+(RPLQQ WOMEN PRIORITY 3 RULES (GIRLS))
+
+(RPLQQ BOY PRIORITY 3 PERSON T RULES (
+      ((0 (NIL PERSON) FRIEND 0)
+	(NIL)
+	(I WOULD LIKE TO MEET YOUR 2 FRIEND ".")
+	(PRE (1 FRIEND 4) FRIEND)
+	(SUPPOSE THE FRIEND WERE NOT A 2 "."))
+      ((0 (NIL PERSON) 0)
+	(NIL)
+	(WHY DO YOU SAY A 2)
+	(WHAT 2 ARE YOU THINKING OF)
+	NEWKEY)
+      ((0 (NIL PERSON) S 0)
+	(NIL)
+	(WHAT GROUP OF 2 ARE YOU THINKING OF)
+	(I EXPECTED THAT YOU WOULD WANT TO TALK ABOUT 2 ".")
+	(DO YOU KNOW MANY 2))))
+
+(RPLQQ GIRL PRIORITY 3 PERSON T RULES (BOY))
+
+(RPLQQ MAN PRIORITY 3 PERSON T RULES (BOY))
+
+(RPLQQ WOMEN PRIORITY 3 PERSON T RULES (BOY))
+
+(RPLQQ SEXY PRIORITY 5 RULES (SEX))
+
+(RPLQQ SEXUAL PRIORITY 5 RULES (SEX))
+
+(RPLQQ SEX PRIORITY 5 RULES (
+      ((0 YOU 0 SEX 0)
+	(NIL)
+	(ARE YOU SURE YOU REALLY 3 IT 5)
+	(DO YOU REALLY WANT TO DISCUSS SEX)
+	(PERHAPS YOU ARE WORRIED THAT YOU 3 IT 5)
+	NEWKEY)
+      ((0)
+	(NIL)
+	(WHAT ARE YOUR REAL FEELINGS ABOUT SEX)
+	(DO YOU EVER DREAM ABOUT SEX)
+	(WHY DO YOU MENTION SEX)
+	(COULD SEX BE PART OF YOUR PROBLEM)
+	NEWKEY))
+    MEMR (
+      ((0 YOU 0 SEX 0)
+	(NIL)
+	(EARLIER YOU SAID YOU 3 4 5 ".")
+	(TELL ME AGAIN WHY YOU 3 4 5 ".")
+	(DO YOU SAY THAT BECAUSE YOU 3 4 5))))
+
+(RPLQQ FRIENDLY PRIORITY 0 RULES (FRIEND))
+
+(RPLQQ FRIEND PRIORITY 1 RULES (
+      ((0 YOUR FRIEND 0)
+	(NIL)
+	(WHAT ELSE CAN YOU TELL ME ABOUT YOUR FRIEND)
+	(WHAT MIGHT YOUR FRIENDS HAVE TO DO WITH YOUR PROBLEM))
+      ((0)
+	(NIL)
+	(DO YOU THINK FRIENDS ARE IMPORTANT)
+	(WHAT DO YOU THINK ABOUT YOUR FRIENDS))))
+
+(RPLQQ CRY PRIORITY 2 RULES (LAUGH))
+
+(RPLQQ LAUGH PRIORITY 2 RULES (
+      ((0 (LAUGH CRY) 0)
+	(NIL)
+	(WHAT WOULD MAKE YOU 2)
+	(REALLY 2)
+	(WOULD YOU LIKE TO LAUGH)
+	NEWKEY)))
+
+(RPLQQ LOVE EMOTION T)
+
+(RPLQQ HATE EMOTION T)
+
+(RPLQQ DISLIKE EMOTION NIL)
+
+(DOCTOR (RDS))
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/E.LSP b/Microsoft muLISP-86 v51/E.LSP
new file mode 100644
index 0000000..efe00de
--- /dev/null
+++ b/Microsoft muLISP-86 v51/E.LSP	
@@ -0,0 +1,48 @@
+; Compute e to 192 digits
+
+(setq digits 200)
+(setq high digits)
+(setq count 0)
+(setq x 0)
+(setq n (- high 1))
+
+(defmacro m-ignore (fun &body body)
+"ignores the return value of a function"
+  `(progn (,fun ,@body)
+  (values)))
+
+(defun rune() (prog ()
+    _nextn_
+        (setf (aref a n) 1)
+        (cond ((plusp n)
+               (setq n (sub1 n))
+               (go _nextn_))
+        )
+
+    (setf (aref a 1) 2)
+    (setf (aref a 0) 0)
+
+    _nexthigh_
+        (setq high (sub1 high))
+        (setq n high)
+        _nextn2_
+            (setf (aref a n) (mod x n))
+            (setq x (+ (* 10 (aref a (sub1 n))) (truncate (/ x n))))
+            (cond ((> n 1)
+                   (setq n (sub1 n))
+                   (go _nextn2_))
+            )
+        (princ x)
+        (cond ((> high 9)
+               (go _nexthigh_))
+        )
+    (return "")
+))
+
+(setq a (make-array digits :initial-element 0 ))
+(setq startTime (time))
+(clear-screen)
+(rune)
+(princ "elapsed hundredths of a second: ") (- (time) startTime) (TERPRI)
+
+(system)
diff --git a/Microsoft muLISP-86 v51/EDIT.LSP b/Microsoft muLISP-86 v51/EDIT.LSP
new file mode 100644
index 0000000..5eb763a
--- /dev/null
+++ b/Microsoft muLISP-86 v51/EDIT.LSP	
@@ -0,0 +1,1733 @@
+; File: EDIT.LSP  (C)		01/06/86	   Soft Warehouse, Inc.
+
+
+(LOOP (PRIN1 (QUOTE *)) (EVAL (READ)) ((NULL RDS)) )
+
+(SETQ *CASE-IGNORE* NIL)
+
+(DEFUN EDIT (*FILE-NAME*
+    *BASE-ROW* *BASE-COL* *ROWS* *COLUMNS*
+    *ABOVE-POINT* *BELOW-POINT* *LEFT-POINT* *RIGHT-POINT*
+    *CURSOR-ROW* *CURSOR-COL* *POINT-ROW* *POINT-COL*
+    *START-ROW* *START-COL* *END-ROW* *END-COL*
+    *LAST-ROW* *LAST-COL* *FIND-ROW* *FIND-COL*
+    *TEMP-ROW* *TEMP-COL* *FIND-STRG* *REPL-STRG*
+    *EVAL-ROW* *DELETED-TEXT* *PAGE-ROWS*
+    *SCREEN* *FULL-WINDOW* *WINDOW-SHAPE* *INSERT*
+    *STAT-RC* *STAT-END* *STAT-ROW* *STAT-COL* *STAT-INS* *STAT-WINDOW*
+    *UNPACKED* *TEXT-DIRTY* CHAR *AUTO-NEWLINE* READ-CHAR RDS )
+  (SETQ *FULL-WINDOW* (MAKE-WINDOW)
+	*INSERT* T
+	*WINDOW-SHAPE* 'F)
+  (MAKE-SCREEN)
+  ( ((IDENTITY *FILE-NAME*))
+    (SETQ *FILE-NAME* (INPUTFILE)) )
+  (SETQ *FIND-STRG* *NUL-STRG* *REPL-STRG* *NUL-STRG*)
+  (COPY-CHAR-TYPE (ASCII 27) 'A)
+  (UNWIND-PROTECT (LOOP
+    ( ((NULL *FILE-NAME*)
+	(LOOP
+	  (CLEAR-STAT)
+	  (SETQ CHAR (PROMPT-READ-CHAR '(E P S L Q)
+			" Edit, Print, Screen, Lisp, Quit: "))
+	  ((EQ CHAR 'Q))
+	  ( ((EQ CHAR 'E)
+	      (SETQ *FILE-NAME* (PROMPT-FILE " Edit file: ")) )
+	    ((EQ CHAR 'P)
+	      (PRINT-FILE (PROMPT-FILE " Print file: ")) )
+	    ((EQ CHAR 'S)
+	      (WINDOW-SHAPE-AUX) )
+	    ((EQ CHAR 'L)
+	      (EVAL-LISP) ) )
+	  ((AND *FILE-NAME* (NEQ *FILE-NAME* *NUL-STRG*))) ) ) )
+    ((EQ CHAR 'Q))
+    (SETQ *BELOW-POINT* NIL *ABOVE-POINT* NIL	;Clear before read
+	*BELOW-POINT* (READ-FILE *FILE-NAME*)
+	*CURSOR-ROW* 0 *CURSOR-COL* 0
+	*POINT-ROW* 0 *POINT-COL* 0
+	*UNPACKED* NIL *TEXT-DIRTY*)
+    (MARK-LAST)
+    (MARK-FIND)
+    (MARK-TEMP)
+    (MARK-START)
+    (MARK-END)
+    (CATCH 'QUIT-EDIT (LOOP
+      (UPDATE-SCRN)
+      (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*)
+      (SETQ CHAR (READ-CHAR))
+      ( ((GET CHAR 'EDIT-CHAR)
+	  (FUNCALL (GET CHAR 'EDIT-CHAR) CHAR) )
+	((<= 32 (ASCII CHAR) 126)
+	  (ADD-CHAR CHAR) ) ) ) )
+    (WRS (FIND "EDIT$.TMP" (OPENFILES) 'FINDSTRING))
+    (WRS) )
+  (COPY-CHAR-TYPE (ASCII 27) (ASCII 27))	;Restore ESC interrupts
+  (APPLY 'MAKE-WINDOW *FULL-WINDOW*)
+  (SET-CURSOR (SUB1 (CADDR *FULL-WINDOW*)) 0) ) )
+
+(DEFUN EDIT-PAIR (CHAR
+    EDIT-CHAR NUM )
+  (STAT-WINDOW)
+  (PRINC '\^)
+  (PRINC (SETQ EDIT-CHAR (ASCII (+ (ASCII CHAR) 64))))
+  (EDIT-WINDOW)
+  (SETQ CHAR 60)		;Prompt display delay time
+  (LOOP
+    (SETQ NUM 30)
+    ((LISTEN))
+    (LOOP
+      ((ZEROP (DECQ NUM))) )
+    ((ZEROP (DECQ CHAR))
+      ((GET EDIT-CHAR 'PROMPT)
+	(CLEAR-STAT)
+	(PRINC (GET EDIT-CHAR 'PROMPT))
+	(SETQ NUM) ) ) )
+  (SETQ CHAR (STRING-UPCASE (READ-CHAR)))
+  (IF (< (ASCII CHAR) 32)
+	(SETQ CHAR (ASCII (+ (ASCII CHAR) 64))) )
+  ( ((NULL NUM)
+      (PRINC CHAR) )
+    (STAT-WINDOW)
+    (SET-CURSOR 0 2)
+    (PRINC CHAR) )
+  (EDIT-WINDOW)
+  (IF (GET CHAR EDIT-CHAR)
+      (FUNCALL (GET CHAR EDIT-CHAR) CHAR) )
+  ((NULL NUM))
+  (STAT-WINDOW)
+  (SPACES 3)
+  (EDIT-WINDOW) )
+
+(DEFUN EVAL-LISP ()
+  (EVAL-EXPN '(DRIVER)) )
+
+(DEFUN EVAL-EXPN (EXPN
+    READ-CHAR RECLAIM *AUTO-NEWLINE* RDS WRS )
+  (EVAL-WINDOW)
+  (SETQ READ-CHAR T  RECLAIM T  *AUTO-NEWLINE* T)
+  (COPY-CHAR-TYPE (ASCII 27) (ASCII 27))	;Restore interrupts
+  (PRINT (CATCH NIL (EVAL EXPN)))
+  (COPY-CHAR-TYPE (ASCII 27) 'A)		;Disable interrupts
+  (SETQ *EVAL-ROW* (ROW)
+	*AUTO-NEWLINE*)
+  (IF (OR (EQ *WINDOW-SHAPE* 'F)
+	  (NEQ 2 (CSMEMORY 855)) )		;IBM PC test
+      (MAKE-SCREEN) )
+  (EDIT-WINDOW) )
+
+
+;	* * *   Cursor line movement functions   * * *
+
+(DEFUN UP-LINE ()		;Move up a line
+  ((ZEROP *POINT-ROW*))
+  (JUMP-POSN (SUB1 *POINT-ROW*) *POINT-COL*) )
+
+(DEFUN DOWN-LINE ()		;Move down a line
+  (JUMP-POSN (ADD1 *POINT-ROW*) *POINT-COL*) )
+
+(DEFUN TOP-ROW ()		;Move to top row
+  ((ZEROP *CURSOR-ROW*))
+  (MARK-LAST)
+  (JUMP-POSN (- *POINT-ROW* *CURSOR-ROW*) *POINT-COL*) )
+
+(DEFUN BOTTOM-ROW ()		;Move to bottom row
+  ((EQ *CURSOR-ROW* (- *ROWS* 2)))
+  (MARK-LAST)
+  (JUMP-POSN (+ *POINT-ROW* (- *ROWS* *CURSOR-ROW*) -2) *POINT-COL*) )
+
+(DEFUN SCROLL-DOWN-LINE ()	;Scroll text down a line
+  ((EQ *POINT-ROW* *CURSOR-ROW*))
+  (SCRN-DOWN 0)
+  ((EQ *CURSOR-ROW* (- *ROWS* 2))
+    (POINT-TO-ROW (SUB1 *POINT-ROW*)) )
+  (INCQ *CURSOR-ROW*) )
+
+(DEFUN SCROLL-UP-LINE ()	;Scroll text up a line
+  (SCRN-UP 0)
+  ((ZEROP *CURSOR-ROW*)
+    (POINT-TO-ROW (ADD1 *POINT-ROW*)) )
+  (DECQ *CURSOR-ROW*) )
+
+(DEFUN SCROLL-DOWN-SCRN ()	;Scroll text down a screenful
+  (MARK-LAST)
+  ((< (- *POINT-ROW* *CURSOR-ROW*) *PAGE-ROWS*)
+    (JUMP-POSN (MAX 0 (- *POINT-ROW* *PAGE-ROWS*)) *POINT-COL*) )
+  (POINT-TO-ROW (- *POINT-ROW* *PAGE-ROWS*)) )
+
+(DEFUN SCROLL-UP-SCRN ()	;Scroll text up a screenful
+  (MARK-LAST)
+  (POINT-TO-ROW (+ *POINT-ROW* *PAGE-ROWS*)) )
+
+(DEFUN START-TEXT ()		;Move to start of text
+  (MARK-LAST)
+  (JUMP-POSN 0 0) )
+
+(DEFUN END-TEXT ()		;Move to end of text
+  (MARK-LAST)
+  (PACK-LINE)
+  (JUMP-POSN (+ *POINT-ROW* (LENGTH *BELOW-POINT*)) 0) )
+
+(DEFUN DOWN-LINE-INDENT (	;Move down a line and indent
+    COL NUM )
+  (MARK-LAST)
+  (LEFT-END)
+  (DOWN-LINE)
+  (UNPACK-LINE)
+  ((AND (NULL *RIGHT-POINT*) (NOT (EQ (CAR *ABOVE-POINT*) *NUL-STRG*)))
+    (SETQ *RIGHT-POINT* (UNPACK (CAR *ABOVE-POINT*))
+	  NUM (* 2 (- (COUNT *LPAR* *RIGHT-POINT*) (COUNT *RPAR* *RIGHT-POINT*)))
+	  COL (POSITION-IF 'NON-WHITESPACE *RIGHT-POINT*))
+    (IF (MINUSP NUM) (SETQ COL (MAX 0 (+ COL NUM))
+			   NUM 0) )
+    (IF (ZEROP COL)
+	  (SETQ *RIGHT-POINT*)
+	  (RPLACD (NTHCDR (SUB1 COL) *RIGHT-POINT*)) )
+    (JUMP-POSN *POINT-ROW* COL)
+    (LOOP
+      ((ZEROP NUM))
+      (ADD-CHAR *BLANK*)
+      (DECQ NUM) ) )
+  ((SETQ COL (POSITION-IF 'NON-WHITESPACE *RIGHT-POINT*))
+    (JUMP-POSN *POINT-ROW* COL) ) )
+
+(DEFUN JUMP-LAST (
+    ROW COL )
+  (SETQ ROW *POINT-ROW* COL *POINT-COL*)
+  (JUMP-POSN *LAST-ROW* *LAST-COL*)
+  (SETQ *LAST-ROW* ROW *LAST-COL* COL) )
+
+(DEFUN MARK-LAST ()
+  (SETQ *LAST-ROW* *POINT-ROW* *LAST-COL* *POINT-COL*) )
+
+
+;	* * *   Cursor column movement functions   * * *
+
+(DEFUN LEFT-CHAR ()		;Move left a character & PREDICATE
+  ((ZEROP *POINT-COL*)
+    ((ZEROP *POINT-ROW*) NIL)
+    (UP-LINE)
+    (RIGHT-END)
+    T )
+  (JUMP-POSN *POINT-ROW* (SUB1 *POINT-COL*))
+  T )
+
+(DEFUN RIGHT-CHAR ()		;Move right a character
+  (UNPACK-LINE)
+  ((BLANK-LINE *RIGHT-POINT*)
+    (LEFT-END)
+    (DOWN-LINE) )
+  (JUMP-POSN *POINT-ROW* (ADD1 *POINT-COL*)) )
+
+(DEFUN LEFT-END ()		;Move to left end
+  ((ZEROP *POINT-COL*))
+  (JUMP-POSN *POINT-ROW* 0) )
+
+(DEFUN RIGHT-END ()		;Move to right end
+  (UNPACK-LINE)
+  (JUMP-POSN *POINT-ROW* (+ *POINT-COL* (LENGTH (TRIM-LINE *RIGHT-POINT*)))) )
+
+(DEFUN LEFT-TAB ()		;Move left to tab stop
+  (LOOP
+    (LEFT-CHAR)
+    ((ZEROP (REM *POINT-COL* 8))) ) )
+
+(DEFUN LEFT-WORD (		;Move left a word & PREDICATE
+    COL )
+  ((ZEROP *POINT-COL*)
+    (LEFT-CHAR) )
+  (LEFT-CHAR)
+  ((ZEROP *POINT-COL*))
+  (UNPACK-LINE)
+  ((OR (NULL *RIGHT-POINT*) (WHITESPACE (CAR *RIGHT-POINT*)))
+    ((WORD-DELIMITER (CAR *LEFT-POINT*))
+      ((NON-WHITESPACE (CAR *LEFT-POINT*))
+	(LEFT-CHAR) )
+      ((SETQ COL (POSITION-IF 'NON-WHITESPACE *LEFT-POINT*))
+	(JUMP-POSN *POINT-ROW* (- *POINT-COL* COL)) )
+      (LEFT-END) )
+    ((SETQ COL (POSITION-IF 'WORD-DELIMITER *LEFT-POINT*))
+      (JUMP-POSN *POINT-ROW* (- *POINT-COL* COL)) )
+    (LEFT-END) )
+  ((SETQ COL (POSITION-IF 'WORD-DELIMITER *LEFT-POINT*))
+    (JUMP-POSN *POINT-ROW* (- *POINT-COL* COL)) )
+  (LEFT-END) )
+
+(DEFUN RIGHT-WORD (		;Move right a word
+    COL NUM )
+  (UNPACK-LINE)
+  ((BLANK-LINE *RIGHT-POINT*)
+    (LEFT-END)
+    (DOWN-LINE)
+    (UNPACK-LINE)
+    ((SETQ COL (POSITION-IF 'NON-WHITESPACE *RIGHT-POINT*))
+      (JUMP-POSN *POINT-ROW* COL) )
+    (RIGHT-END) )
+  ((AND (SETQ COL (POSITION-IF 'WORD-DELIMITER (CDR *RIGHT-POINT*)))
+	(SETQ NUM (POSITION-IF 'NON-WHITESPACE
+			       (NTHCDR COL (CDR *RIGHT-POINT*)))))
+    (JUMP-POSN *POINT-ROW* (+ *POINT-COL* COL NUM 1)) )
+  (RIGHT-END) )
+
+
+;	* * *   Text insertion functions   * * *
+
+(DEFUN ADD-CHAR (CHAR		;Add new character to line
+    SCREEN )
+  (UNPACK-LINE)
+  ( ((NULL *RIGHT-POINT*)
+      (SETQ *TEXT-DIRTY* T
+	    *RIGHT-POINT* (LIST CHAR)) )
+    ((NULL *INSERT*)
+      ((EQ (CAR *RIGHT-POINT*) CHAR))
+      (SETQ *TEXT-DIRTY* T)
+      (RPLACA *RIGHT-POINT* CHAR) )
+    (SETQ *TEXT-DIRTY* T)
+    (ADJUST-COL 1)
+    (SETQ *RIGHT-POINT* (ADJUST-TAB (ADD1 *POINT-COL*) *RIGHT-POINT*))
+    (PUSH CHAR *RIGHT-POINT*) )
+  (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*)
+  (WRITE-STRING CHAR)
+  (SETQ SCREEN (NTHCDR *CURSOR-ROW* *SCREEN*))
+  (IF (ATOM (CAR SCREEN))
+	(RPLACA SCREEN (NCONC (UNPACK (CAR SCREEN))
+		(MAKE-LIST (- *COLUMNS* (LENGTH (CAR SCREEN))) *BLANK*))) )
+  (RPLACA (NTHCDR *CURSOR-COL* (CAR SCREEN)) CHAR)
+  (JUMP-POSN *POINT-ROW* (ADD1 *POINT-COL*)) )
+
+(DEFUN ESCAPE-CHAR (		;Add escape character
+    CHAR )
+  ((EQ (SETQ CHAR (READ-CHAR)) *TAB*)
+    (LOOP
+      ((EQ (REM *POINT-COL* 8) 7)
+	(ADD-CHAR *TAB*) )
+      (ADD-CHAR *BLANK*) ) )
+  (ADD-CHAR CHAR) )
+
+(DEFUN INSERT-LINE ()		;Insert a new line
+  (SETQ *TEXT-DIRTY* T)
+  (UNPACK-LINE)
+  (ADJUST-ROW 1)
+  (PUSH (PACK (ADJUST-TAB 0 *RIGHT-POINT*)) *BELOW-POINT*)
+  (SETQ *RIGHT-POINT*)
+  ((ZEROP *POINT-COL*)
+    (SCRN-DOWN *CURSOR-ROW*) )
+  (SCRN-DOWN (ADD1 *CURSOR-ROW*)) )
+
+(DEFUN NEW-LINE ()		;Move to left end and down a line
+  ( ((NULL *INSERT*))
+    (INSERT-LINE) )
+  (LEFT-END)
+  (DOWN-LINE) )
+
+(DEFUN RIGHT-TAB ()		;Move right to tab stop
+  ((NULL *INSERT*)
+    (UNPACK-LINE)
+    (LOOP
+      ((BLANK-LINE *RIGHT-POINT*)
+	(LOOP
+	  ((EQ (REM *POINT-COL* 8) 7)
+	    (ADD-CHAR *TAB*) )
+	  (ADD-CHAR *BLANK*) ) )
+      (JUMP-POSN *POINT-ROW* (ADD1 *POINT-COL*))
+      ((ZEROP (REM *POINT-COL* 8))) ) )
+  (LOOP
+    ((EQ (REM *POINT-COL* 8) 7)
+      (ADD-CHAR *TAB*) )
+    (ADD-CHAR *BLANK*) ) )
+
+(DEFUN INSERT-MODE ()		;Toggle INSERT/REPLACE mode
+  (SETQ *INSERT* (NOT *INSERT*))
+  (SETQ *STAT-INS*) )
+
+
+;	* * *   Text deletion functions   * * *
+
+(DEFUN DEL-RIGHT-CHAR ()		;Delete character under cursor
+  (UNPACK-LINE)
+  ((BLANK-LINE *RIGHT-POINT*)
+    (DEL-CRLF) )
+  (DEL-CHAR) )
+
+(DEFUN DEL-LEFT-CHAR ()		;Delete character to left of cursor
+  (UNPACK-LINE)
+  ((LEFT-CHAR)
+    (UNPACK-LINE)
+    ((NULL *RIGHT-POINT*)
+      (DEL-CRLF) )
+    (DEL-CHAR) ) )
+
+(DEFUN DEL-RIGHT-END ()		;Delete right end of line
+  (UNPACK-LINE)
+  ((NULL *RIGHT-POINT*))
+  (SETQ *TEXT-DIRTY* T
+	*RIGHT-POINT*) )
+
+(DEFUN DEL-LEFT-END (		;Delete left end of line
+    COL )
+  ((ZEROP *POINT-COL*))
+  (SETQ *TEXT-DIRTY* T
+	COL *POINT-COL*)
+  (LEFT-END)
+  (UNPACK-LINE)
+  (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL* (NTHCDR COL *RIGHT-POINT*))) )
+
+(DEFUN DEL-RIGHT-WORD ()	;Delete word under cursor
+  (UNPACK-LINE)
+  ((BLANK-LINE *RIGHT-POINT*)
+    (DEL-CRLF) )
+  ((WHITESPACE (CAR *RIGHT-POINT*))
+    (LOOP
+      (DEL-CHAR)
+      ((NON-WHITESPACE (CAR *RIGHT-POINT*))) ) )
+  ((WORD-DELIMITER (CAR *RIGHT-POINT*))
+    (DEL-CHAR) )
+  (LOOP
+    ((WORD-DELIMITER (CAR *RIGHT-POINT*))
+      ((OR (ZEROP *POINT-COL*) (WHITESPACE (CAR *LEFT-POINT*)))
+	(LOOP
+	  ((NULL *RIGHT-POINT*))
+	  ((NON-WHITESPACE (CAR *RIGHT-POINT*)))
+	  ((AND (EQ *TAB* (FIND *BLANK* *RIGHT-POINT* 'NEQ))
+	      (< (POSITION *TAB* *RIGHT-POINT*) (- 8 (REM *POINT-COL* 8)))))
+	  (ADJUST-COL -1)
+	  (SETQ *RIGHT-POINT*
+			(ADJUST-TAB *POINT-COL* (CDR *RIGHT-POINT*))) ) ) )
+    (DEL-CHAR)
+    ((NULL *RIGHT-POINT*)) ) )
+
+(DEFUN DEL-LEFT-WORD ()		;Delete word left of cursor
+  ((AND (ZEROP *POINT-ROW*) (ZEROP *POINT-COL*)))
+  (UNPACK-LINE)
+  (LEFT-WORD)
+  (DEL-RIGHT-WORD) )
+
+(DEFUN DEL-LINE ()		;Delete entire line
+  (LEFT-END)
+  (PACK-LINE)
+  ((NULL *BELOW-POINT*))
+  (SETQ *TEXT-DIRTY* T)
+  (ADJUST-ROW -1)
+  (SCRN-UP *CURSOR-ROW*)
+  ((EQ (CAR *BELOW-POINT*) *NUL-STRG*)
+    (POP *BELOW-POINT*) )
+  (SETQ *DELETED-TEXT* (LIST (POP *BELOW-POINT*) *NUL-STRG*)) )
+
+(DEFUN DEL-CRLF ()
+  ((NULL *BELOW-POINT*))
+  ((ZEROP *POINT-COL*)
+    (DEL-LINE) )
+  (SETQ *TEXT-DIRTY* T)
+  (ADJUST-ROW-COL *POINT-COL*)
+  (ADJUST-ROW -1)
+  (SCRN-UP (ADD1 *CURSOR-ROW*))
+  (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL* (UNPACK (POP *BELOW-POINT*)))) )
+
+(DEFUN DEL-CHAR ()
+  (SETQ *TEXT-DIRTY* T)
+  ((AND (EQ *TAB* (FIND *BLANK* *RIGHT-POINT* 'NEQ))
+	(< (POSITION *TAB* *RIGHT-POINT*) (- 8 (REM *POINT-COL* 8))))
+    (ADJUST-COL (- -1 (POSITION *TAB* *RIGHT-POINT*)))
+    (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL*
+				    (CDR (MEMBER *TAB* *RIGHT-POINT*)))) )
+  (ADJUST-COL -1)
+  (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL* (CDR *RIGHT-POINT*))) )
+
+
+;	* * *   Search and replace functions   * * *
+
+ (DEFUN FIND-STRG ()		;Find string
+  (SETQ *FIND-STRG* (PROMPT-READ-LINE " Find string: ")
+	*REPL-STRG* *FIND-STRG*)
+  (FIND-NEXT) )
+
+(DEFUN REPL-STRG ()		;Find and replace string once
+  (SETQ *FIND-STRG* (PROMPT-READ-LINE " Find string: ")
+	*REPL-STRG* (PROMPT-READ-LINE " Replace with: "))
+  (FIND-NEXT) )
+
+(DEFUN REPL-ALL ()		;Find and replace string all
+  (LOOP
+    ((NULL (FIND-NEXT))) ) )
+
+(DEFUN FIND-NEXT (		;Find (and replace) next string & PREDICATE
+    TEXT ROW COL )
+  (EDIT-WINDOW)
+  ((EQ *FIND-STRG* *NUL-STRG*) NIL)
+  (MARK-FIND)
+  (UNPACK-LINE)
+  ((SETQ COL (IF *CASE-IGNORE*
+	(FINDSTRING (STRING-UPCASE *FIND-STRG*)
+		    (STRING-UPCASE (PACK (CDR *RIGHT-POINT*))))
+	(FINDSTRING *FIND-STRG* (PACK (CDR *RIGHT-POINT*)))))
+    (JUMP-POSN *POINT-ROW* (+ *POINT-COL* COL 1))
+    (REPL-NEXT) )
+  (SETQ TEXT *BELOW-POINT*
+	ROW *POINT-ROW*)
+  (LOOP
+    ((NULL TEXT)
+      (END-TEXT) NIL )
+    (INCQ ROW)
+    ((SETQ COL (IF *CASE-IGNORE*
+	(FINDSTRING (STRING-UPCASE *FIND-STRG*) (STRING-UPCASE (POP TEXT)))
+	(FINDSTRING *FIND-STRG* (POP TEXT))))
+      (JUMP-POSN ROW COL)
+      (REPL-NEXT) ) ) )
+
+(DEFUN REPL-NEXT (		;Find and replace next string & PREDICATE
+    TEXT-LINE *BLINK* CHAR)
+  ((EQ *FIND-STRG* *REPL-STRG*) NIL)
+  (UPDATE-SCRN)
+  (CLEAR-STAT)
+  (WRITE-STRING " Replace string (Y/N/Q)")
+  (SETQ *BLINK* T)
+  (PRINC '?)
+  (SETQ *BLINK*)
+  (EDIT-WINDOW)
+  ((EQ (SETQ CHAR (STRING-UPCASE (READ-CHAR))) 'Q) NIL)
+  ((NEQ CHAR 'Y))
+  (SETQ *TEXT-DIRTY* T)
+  (UNPACK-LINE)
+  (ADJUST-COL (- (LENGTH *REPL-STRG*) (LENGTH *FIND-STRG*)))
+  (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL* (NCONC (UNPACK *REPL-STRG*)
+			     (NTHCDR (LENGTH *FIND-STRG*) *RIGHT-POINT*))))
+  (JUMP-POSN *POINT-ROW* (+ *POINT-COL* (LENGTH *REPL-STRG*))) )
+
+(DEFUN JUMP-FIND ()
+  (MARK-LAST)
+  (JUMP-POSN *FIND-ROW* *FIND-COL*) )
+
+(DEFUN MARK-FIND ()
+  (SETQ *FIND-ROW* *POINT-ROW* *FIND-COL* *POINT-COL*) )
+
+
+;	* * *   Block operation functions   * * *
+
+(DEFUN MARK-START ()
+  (SETQ *START-ROW* *POINT-ROW* *START-COL* *POINT-COL*) )
+
+(DEFUN JUMP-START ()
+  (MARK-LAST)
+  (JUMP-POSN *START-ROW* *START-COL*) )
+
+(DEFUN MARK-END ()
+  (SETQ *END-ROW* *POINT-ROW* *END-COL* *POINT-COL*) )
+
+(DEFUN JUMP-END ()
+  (MARK-LAST)
+  (JUMP-POSN *END-ROW* *END-COL*) )
+
+(DEFUN MARK-TEMP ()
+  (SETQ *TEMP-ROW* *POINT-ROW* *TEMP-COL* *POINT-COL*) )
+
+(DEFUN JUMP-TEMP ()
+  (POINT-TO-POSN *TEMP-ROW* *TEMP-COL*) )
+
+(DEFUN WRITE-BLOCK ()
+  (WRITE-FILE (PROMPT-FILE " Write file: ") (TEXT-BLOCK)) )
+
+(DEFUN READ-BLOCK ()
+  (INSERT-TEXT (READ-FILE (PROMPT-FILE " Read file: "))) )
+
+(DEFUN UNDELETE ()		;Undo last command
+  (INSERT-TEXT *DELETED-TEXT*) )
+
+(DEFUN MOVE-BLOCK ()		;Move block to point
+  (INSERT-TEXT (DEL-BLOCK-AUX)) )
+
+(DEFUN COPY-BLOCK ()		;Copy block to point
+  (INSERT-TEXT (TEXT-BLOCK)) )
+
+(DEFUN DEL-BLOCK ()		;Delete block
+  (IF (OR (> *POINT-ROW* *START-ROW*)
+	  (AND (EQ *POINT-ROW* *START-ROW*) (> *POINT-COL* *START-COL*)))
+	(JUMP-START) )
+  (DEL-BLOCK-AUX) )
+
+(DEFUN DEL-BLOCK-AUX (
+    TEXT *SCROLL-FLAG* )
+  (SETQ TEXT (GET-BLOCK))
+  ((OR (NULL TEXT) (EQUAL TEXT (LIST *NUL-STRG*)))
+    (JUMP-TEMP)
+    TEXT )
+  (SETQ *DELETED-TEXT* TEXT)
+  ( ((EQ *START-ROW* *END-ROW*))
+    (DEL-RIGHT-END)
+    (SETQ *BELOW-POINT* (NTHCDR (- *END-ROW* *START-ROW* 1) *BELOW-POINT*))
+    (ADJUST-ROW (- *START-ROW* *END-ROW* -1))
+    (DEL-RIGHT-CHAR) )
+  (LOOP
+    ((>= *START-COL* *END-COL*))
+    (DEL-RIGHT-CHAR) )
+  (JUMP-TEMP)
+  TEXT )
+
+(DEFUN TEXT-BLOCK ()		;Text in block
+  (PROG1 (GET-BLOCK) (JUMP-TEMP)) )
+
+(DEFUN GET-BLOCK (
+    TEXT )
+  (MARK-TEMP)
+  (POINT-TO-POSN *START-ROW* *START-COL*)
+  (PACK-LINE)
+  ((SETQ TEXT (FIRSTN (- *END-ROW* *START-ROW* -1) *BELOW-POINT*))
+    (IF (< (LENGTH TEXT) (- *END-ROW* *START-ROW* -1))
+	(NCONC TEXT (LIST *NUL-STRG*)) )
+    (RPLACA (LAST TEXT) (IF (ZEROP *END-COL*) *NUL-STRG*
+		 (SUBSTRING (CAR (LAST TEXT)) 0 (SUB1 *END-COL*))) )
+    (RPLACA TEXT (PACK (ADJUST-TAB 0
+		 (UNPACK (SUBSTRING (CAR TEXT) *START-COL*)))))
+    TEXT ) )
+
+(DEFUN INSERT-TEXT (TEXT	;Insert text at cursor
+    *SCROLL-FLAG* )
+  ((NULL TEXT))
+  (UNPACK-LINE)
+  (SETQ *RIGHT-POINT* (ADJUST-TAB *POINT-COL*
+		(NCONC (UNPACK (CAR (LAST TEXT))) *RIGHT-POINT*)))
+  (INSERT-LINE)
+  (SETQ *BELOW-POINT* (NCONC (BUTLAST TEXT) *BELOW-POINT*))
+  (ADJUST-ROW (SUB1 (LENGTH TEXT)))
+  (DEL-RIGHT-CHAR) )
+
+
+;	* * *   LISP movement functions   * * *
+
+(DEFUN LEFT-UP-LIST ()		;Move left and up list
+  (LEFT-LIST)
+  (LEFT-LIST) )
+
+(DEFUN LEFT-SEXP (		;Move cursor left S-expression
+    CHAR LINE TEXT ROW COL )
+  (PACK-LINE)
+  (SETQ LINE (CAR *BELOW-POINT*)  TEXT *ABOVE-POINT*
+	ROW *POINT-ROW*  COL *POINT-COL*)
+  (LOOP
+    ((NULL (SETQ CHAR (GET-LAST-CHAR)))
+      (JUMP-POSN 0 0) )
+    ((EQ CHAR *LPAR*)
+      (JUMP-POSN ROW COL) )
+    ((EQ CHAR *RPAR*)
+      ((MATCHING-LPAR 1)
+	(JUMP-POSN ROW COL) )
+      (JUMP-POSN 0 0) )
+    ((NON-WHITESPACE CHAR)
+      (LOOP
+	((ZEROP COL)
+	  (JUMP-POSN ROW COL) )
+	((MEMBER (GET-LAST-CHAR) *ATOM-DELIMITER*)
+	  (JUMP-POSN ROW (ADD1 COL)) ) ) ) ) )
+
+(DEFUN LEFT-LIST (		;Move cursor left list
+    LINE TEXT ROW COL )
+  (PACK-LINE)
+  (SETQ LINE (CAR *BELOW-POINT*)  TEXT *ABOVE-POINT*
+	ROW *POINT-ROW*  COL *POINT-COL*)
+  ((MATCHING-LPAR 1)
+    (JUMP-POSN ROW COL) )
+  (JUMP-POSN 0 0) )
+
+(DEFUN MATCHING-LPAR (NUM LISTEN
+    CHAR )
+  (LOOP
+    ((NULL (SETQ CHAR (GET-LAST-CHAR))) NIL)
+    ( ((EQ *SINGLE-ESCAPE* (CHAR LINE (SUB1 COL))))
+      ((EQ CHAR *LPAR*)
+	(DECQ NUM) )
+      ((EQ CHAR *RPAR*)
+	(INCQ NUM) )
+      ((EQ CHAR *MULTIPLE-ESCAPE*)
+	(LOOP
+	  ((NULL (SETQ CHAR (GET-LAST-CHAR))))
+	  ((AND (EQ CHAR *MULTIPLE-ESCAPE*)
+		(NEQ *SINGLE-ESCAPE* (CHAR LINE (SUB1 COL))))) ) )
+      ((EQ CHAR \")
+	(LOOP
+	  ((NULL (SETQ CHAR (GET-LAST-CHAR))))
+	  ((AND (EQ CHAR \")
+		(NEQ *SINGLE-ESCAPE* (CHAR LINE (SUB1 COL))))) ) ) )
+    ((NULL CHAR) NIL)
+    ((ZEROP NUM))
+    ((AND LISTEN (LISTEN)) NIL) ) )
+
+(DEFUN GET-LAST-CHAR ()		;Get last character & PREDICATE
+  (LOOP
+    ((PLUSP COL)
+      ((CHAR LINE (DECQ COL)))
+      (GET-LAST-CHAR) )
+    ((NULL TEXT) NIL)
+    ((MINUSP (DECQ ROW)) NIL)
+    (SETQ LINE (POP TEXT)
+	  COL (LENGTH LINE)) ) )
+
+
+(DEFUN RIGHT-UP-LIST ()		;Move right and up list
+  (RIGHT-LIST)
+  (RIGHT-LIST) )
+
+(DEFUN RIGHT-DOWN-LIST ()	;Move right and down list
+  (LOOP
+    (UNPACK-LINE)
+    ((EQ (CAR *RIGHT-POINT*) *LPAR*)
+      (RIGHT-CHAR) )
+    ((EQ (CAR *RIGHT-POINT*) *RPAR*))
+    ((NULL (RIGHT-SEXP))) ) )
+
+(DEFUN RIGHT-SEXP (		;Move cursor right S-expression & PREDICATE
+    CHAR LINE TEXT ROW COL )
+  (PACK-LINE)
+  (SETQ LINE (CAR *BELOW-POINT*)  TEXT (CDR *BELOW-POINT*)
+	ROW *POINT-ROW*  COL *POINT-COL*)
+  (LOOP
+    ((NULL (SETQ CHAR (GET-NEXT-CHAR)))
+      (JUMP-POSN ROW (SUB1 COL)) NIL)
+    ((EQ CHAR *RPAR*)
+      (SKIP-WS) )
+    ((EQ CHAR *LPAR*)
+      ((MATCHING-RPAR 1)
+	(SKIP-WS) )
+      (JUMP-POSN ROW (SUB1 COL)) NIL)
+    ((NON-WHITESPACE CHAR)
+      (LOOP
+	((NULL (CHAR LINE COL))
+	  (JUMP-POSN ROW COL) )
+	(SETQ CHAR (GET-NEXT-CHAR))
+	((OR (EQ CHAR *LPAR*) (EQ CHAR *RPAR*))
+	  (JUMP-POSN ROW (SUB1 COL)) )
+	((WHITESPACE CHAR)
+	  (SKIP-WS) ) ) ) ) )
+
+(DEFUN RIGHT-LIST (		;Move cursor right list
+    LINE TEXT ROW COL )
+  (PACK-LINE)
+  (SETQ LINE (CAR *BELOW-POINT*)  TEXT (CDR *BELOW-POINT*)
+	ROW *POINT-ROW*  COL *POINT-COL*)
+  ((MATCHING-RPAR 1)
+    (SKIP-WS) )
+  (JUMP-POSN ROW (SUB1 COL)) )
+
+(DEFUN MATCHING-RPAR (NUM LISTEN
+    CHAR )
+  (LOOP
+    ((AND LISTEN (LISTEN)) NIL)
+    ((NULL (SETQ CHAR (GET-NEXT-CHAR))) NIL)
+    ( ((EQ CHAR *RPAR*)
+	(DECQ NUM) )
+      ((EQ CHAR *LPAR*)
+	(INCQ NUM) )
+      ((EQ CHAR *SINGLE-ESCAPE*)
+	(SETQ CHAR (GET-NEXT-CHAR)) )
+      ((EQ CHAR *MULTIPLE-ESCAPE*)
+	(LOOP
+	  ((NULL (SETQ CHAR (GET-NEXT-CHAR))))
+	  ((EQ CHAR *MULTIPLE-ESCAPE*))
+	  (IF (EQ CHAR *SINGLE-ESCAPE*) (GET-NEXT-CHAR)) ) )
+      ((EQ CHAR \")
+	(LOOP
+	  ((NULL (SETQ CHAR (GET-NEXT-CHAR))))
+	  ((EQ CHAR \"))
+	  (IF (EQ CHAR *SINGLE-ESCAPE*) (GET-NEXT-CHAR)) ) )
+      ((EQ CHAR \;)
+	((NULL TEXT)
+	  (SETQ CHAR) )
+	(INCQ ROW)
+	(SETQ LINE (POP TEXT)
+	      COL 0) ) )
+    ((NULL CHAR) NIL)
+    ((AND LISTEN (EQ ROW *ROWS*)) NIL)
+    ((ZEROP NUM)) ) )
+
+(DEFUN SKIP-WS (		;Skip whitespace characters
+    CHAR )
+  (LOOP
+    ((NULL (SETQ CHAR (GET-NEXT-CHAR)))
+      (JUMP-POSN ROW (SUB1 COL)) )
+    ((NON-WHITESPACE CHAR)
+      (JUMP-POSN ROW (SUB1 COL)) ) ) )
+
+(DEFUN GET-NEXT-CHAR ()		;Get next character & PREDICATE
+  (LOOP
+    ((CHAR LINE COL (INCQ COL)))
+    ((NULL TEXT) NIL)
+    (INCQ ROW)
+    (SETQ LINE (POP TEXT)
+	  COL 0) ) )
+
+
+(DEFUN THIS-DEFN (		;Move cursor to start of this defun
+    TEXT ROW )
+  (PACK-LINE)
+  ((AND (NOT (ZEROP *POINT-COL*)) *BELOW-POINT*
+	(NEQ (CHAR (CAR *BELOW-POINT*) 0) '\;)
+	(NON-WHITESPACE (CHAR (CAR *BELOW-POINT*) 0)))
+    (LEFT-END) )
+  (SETQ TEXT *ABOVE-POINT*
+	ROW *POINT-ROW* )
+  (LOOP
+    ((NULL TEXT))
+    (DECQ ROW)
+    ((AND (NEQ (CAR TEXT) *NUL-STRG*)
+	  (NEQ (CHAR (CAR TEXT) 0) '\;)
+	  (NON-WHITESPACE (CHAR (CAR TEXT) 0))))
+    (POP TEXT) )
+  (JUMP-POSN ROW 0) )
+
+(DEFUN NEXT-DEFN (		;Move cursor to start of next defun
+    TEXT ROW )
+  (PACK-LINE)
+  ((NULL *BELOW-POINT*))
+  (SETQ TEXT (CDR *BELOW-POINT*)
+	ROW *POINT-ROW* )
+  (LOOP
+    (INCQ ROW)
+    ((NULL TEXT))
+    ((AND (NEQ (CAR TEXT) *NUL-STRG*)
+	  (NEQ (CHAR (CAR TEXT) 0) '\;)
+	  (NON-WHITESPACE (CHAR (CAR TEXT) 0))))
+    (POP TEXT) )
+  (JUMP-POSN ROW 0) )
+
+(DEFUN DEL-SEXP ()		;Delete S-expression
+  (MARK-START)
+  (RIGHT-SEXP)
+  (MARK-END)
+  (DEL-BLOCK) )
+
+(DEFUN DEL-DEFN ()		;Delete defun
+  (LEFT-END)
+  (UNPACK-LINE)
+  ( ((AND (NEQ (CAR *RIGHT-POINT*) '\;)
+	  (NON-WHITESPACE (CAR *RIGHT-POINT*))))
+    (THIS-DEFN) )
+  (DEL-SEXP) )
+
+(DEFUN EVAL-SEXP (		;Eval S-expression
+    TEXT *SCROLL-FLAG* )
+  (MARK-START)
+  (RIGHT-SEXP)
+  (MARK-END)
+  (JUMP-POSN *START-ROW* *START-COL*)
+  (SETQ TEXT (TEXT-BLOCK))
+  ((OR (NULL TEXT) (EQUAL TEXT (LIST *NUL-STRG*))))
+  (WRS "EDIT$.TMP" T)
+  (MAPC 'WRITE-LINE TEXT)
+  (WRITE-BYTE 26)
+  (WRITEPTR 0)
+  (SETQ WRS)
+  (RDS "EDIT$.TMP")
+  (READPTR 0)
+  (SETQ TEXT (READ))
+  (RDS)
+  (EVAL-EXPN TEXT) )
+
+
+;	* * *   Cursor movement primitives   * * *
+
+(DEFUN JUMP-POSN (ROW COL	;Move cursor & point to ROW and COL
+    TOP-ROW )			;Returns a nonNIL value
+  ( ((EQ ROW *POINT-ROW*))		;Move cursor to ROW
+    (SETQ TOP-ROW (- *POINT-ROW* *CURSOR-ROW*))
+    ((< ROW TOP-ROW)
+      ((>= ROW (- TOP-ROW (SHIFT *ROWS* -2)))
+	(SETQ *CURSOR-ROW* 0
+	      TOP-ROW (- TOP-ROW ROW))
+	(LOOP
+	  (SCRN-DOWN 0)
+	  ((ZEROP (DECQ TOP-ROW))) ) )
+      (SETQ *CURSOR-ROW* (SHIFT *ROWS* -1)) )
+    ((<= ROW (+ TOP-ROW *ROWS* -2))
+      (SETQ *CURSOR-ROW* (- ROW TOP-ROW)) )
+    ((<= ROW (+ TOP-ROW *ROWS* (SHIFT *ROWS* -2)))
+      (SETQ *CURSOR-ROW* (- *ROWS* 2)
+	    TOP-ROW (- ROW *CURSOR-ROW* TOP-ROW))
+      (LOOP
+	(SCRN-UP 0)
+	((ZEROP (DECQ TOP-ROW))) ) )
+    (SETQ *CURSOR-ROW* (SHIFT *ROWS* -1)) )
+  (IF (> *CURSOR-ROW* ROW) (SETQ *CURSOR-ROW* ROW))
+  ( ((EQ COL *POINT-COL*))		;Move cursor to COL
+    ((< COL (- *POINT-COL* *CURSOR-COL*))
+      (SETQ *CURSOR-COL* (+ (REM COL 8) (* 8 (TRUNCATE *COLUMNS* 32)))) )
+    ((>= COL (+ (- *POINT-COL* *CURSOR-COL*) *COLUMNS*))
+      (SETQ *CURSOR-COL* (+ (REM COL 8) (* 24 (TRUNCATE *COLUMNS* 32)))) )
+    (INCQ *CURSOR-COL* (- COL *POINT-COL*)) )
+  (IF (> *CURSOR-COL* COL) (SETQ *CURSOR-COL* COL))
+  (POINT-TO-POSN ROW COL)
+  'T )
+
+(DEFUN POINT-TO-POSN (ROW COL)		;Move point to ROW and COL
+  (POINT-TO-ROW ROW)
+  (POINT-TO-COL COL) )
+
+(DEFUN POINT-TO-ROW (ROW		;Move point to ROW
+    LST1 LST2 )
+  ((EQ ROW *POINT-ROW*))
+  (PACK-LINE)
+  ((< *POINT-ROW* ROW)
+    (SETQ LST1 *BELOW-POINT*
+	  LST2 (NTHCDR (- ROW *POINT-ROW* 1) LST1))
+    ((NULL LST2)
+      (SETQ *ABOVE-POINT* (MAKE-LIST
+			(- ROW *POINT-ROW* (LENGTH *BELOW-POINT*))
+			*NUL-STRG* (NREVERSE *BELOW-POINT* *ABOVE-POINT*))
+	    *POINT-ROW* ROW
+	    *BELOW-POINT*) )
+    (SETQ *BELOW-POINT* (CDR LST2))
+    (RPLACD LST2)
+    (SETQ *ABOVE-POINT* (NREVERSE LST1 *ABOVE-POINT*)
+	  *POINT-ROW* ROW) )
+  (SETQ LST1 *ABOVE-POINT*
+	LST2 (NTHCDR (- *POINT-ROW* ROW 1) LST1)
+	*ABOVE-POINT* (CDR LST2))
+  (RPLACD LST2)
+  (SETQ *BELOW-POINT* (TRIM-TEXT (NREVERSE LST1 *BELOW-POINT*))
+	*POINT-ROW* ROW) )
+
+(DEFUN POINT-TO-COL (COL		;Move point to COL
+    LST1 LST2 )
+  ((EQ COL *POINT-COL*))
+  ((NOT *UNPACKED*)
+    (SETQ *POINT-COL* COL) )
+  ((< *POINT-COL* COL)
+    (SETQ LST1 *RIGHT-POINT*
+	  LST2 (NTHCDR (- COL *POINT-COL* 1) LST1))
+    ((NULL LST2)
+      (SETQ *LEFT-POINT* (MAKE-LIST
+			(- COL *POINT-COL* (LENGTH *RIGHT-POINT*))
+			*BLANK* (NREVERSE *RIGHT-POINT* *LEFT-POINT*))
+	    *POINT-COL* COL
+	    *RIGHT-POINT*) )
+    (SETQ *RIGHT-POINT* (CDR LST2))
+    (RPLACD LST2)
+    (SETQ *LEFT-POINT* (NREVERSE LST1 *LEFT-POINT*)
+	  *POINT-COL* COL) )
+  (SETQ LST1 *LEFT-POINT*
+	LST2 (NTHCDR (- *POINT-COL* COL 1) LST1)
+	*LEFT-POINT* (CDR LST2))
+  (RPLACD LST2)
+  (SETQ *RIGHT-POINT* (NREVERSE LST1 *RIGHT-POINT*)
+	*POINT-COL* COL) )
+
+(DEFUN SCRN-UP (ROW
+    SCREEN )
+  ((AND *SCROLL-FLAG* (SET-CURSOR ROW 0) (DELETE-LINES 1))
+    (NCONC *SCREEN* (CONS *NUL-STRG*))
+    (SETQ SCREEN (NTHCDR ROW *SCREEN*))
+    (RPLACA SCREEN (CADR SCREEN))
+    (RPLACD SCREEN (CDDR SCREEN)) ) )
+
+(DEFUN SCRN-DOWN (ROW
+    SCREEN )
+  ((AND *SCROLL-FLAG* (SET-CURSOR ROW 0) (INSERT-LINES 1))
+    (SETQ SCREEN (NTHCDR ROW *SCREEN*))
+    (RPLACD SCREEN (CONS (CAR SCREEN) (CDR SCREEN)))
+    (RPLACA SCREEN *NUL-STRG*)
+    (NBUTLAST *SCREEN*) ) )
+
+(DEFUN UNPACK-LINE ()
+  ((IDENTITY *UNPACKED*))
+  (SETQ *UNPACKED* T)
+  (IF *BELOW-POINT*
+	(SETQ *RIGHT-POINT* (UNPACK (POP *BELOW-POINT*)))
+	(SETQ *RIGHT-POINT*) )
+  ((ZEROP *POINT-COL*)
+    (SETQ *LEFT-POINT*) )
+  ((< (LENGTH *RIGHT-POINT*) *POINT-COL*)
+    (SETQ *LEFT-POINT* (MAKE-LIST (- *POINT-COL* (LENGTH *RIGHT-POINT*))
+				  *BLANK* (NREVERSE *RIGHT-POINT*))
+	  *RIGHT-POINT*) )
+  (SETQ *LEFT-POINT* *RIGHT-POINT*)
+  ((LAMBDA (LST)
+	(SETQ *RIGHT-POINT* (CDR LST))
+	(RPLACD LST) )
+    (NTHCDR (SUB1 *POINT-COL*) *RIGHT-POINT*))
+  (SETQ *LEFT-POINT* (NREVERSE *LEFT-POINT*)) )
+
+(DEFUN PACK-LINE ()
+  ((NOT *UNPACKED*))
+  (SETQ *UNPACKED*)
+  (SETQ *RIGHT-POINT* (TRIM-LINE (NREVERSE *LEFT-POINT* *RIGHT-POINT*)))
+  ((OR *BELOW-POINT* *RIGHT-POINT*)
+    (PUSH (PACK *RIGHT-POINT*) *BELOW-POINT*) ) )
+
+(DEFUN ADJUST-ROW (ROW)
+  ( ((> *LAST-ROW* *POINT-ROW*)
+      (INCQ *LAST-ROW* ROW) ) )
+  ( ((> *FIND-ROW* *POINT-ROW*)
+      (INCQ *FIND-ROW* ROW) ) )
+  ( ((> *TEMP-ROW* *POINT-ROW*)
+      (INCQ *TEMP-ROW* ROW) ) )
+  ( ((> *START-ROW* *POINT-ROW*)
+      (INCQ *START-ROW* ROW) ) )
+  ((> *END-ROW* *POINT-ROW*)
+    (INCQ *END-ROW* ROW) ) )
+
+(DEFUN ADJUST-ROW-COL (COL
+    *POINT-COL* )
+  (SETQ *POINT-COL* -1)
+  (INCQ *POINT-ROW*)
+  (ADJUST-COL COL)
+  (DECQ *POINT-ROW*) )
+
+(DEFUN ADJUST-COL (COL)
+  (AND (EQ *LAST-ROW* *POINT-ROW*) (> *LAST-COL* *POINT-COL*)
+    (INCQ *LAST-COL* COL) )
+  (AND (EQ *FIND-ROW* *POINT-ROW*) (> *FIND-COL* *POINT-COL*)
+    (INCQ *FIND-COL* COL) )
+  (AND (EQ *TEMP-ROW* *POINT-ROW*) (> *TEMP-COL* *POINT-COL*)
+    (INCQ *TEMP-COL* COL) )
+  (AND (EQ *START-ROW* *POINT-ROW*) (> *START-COL* *POINT-COL*)
+    (INCQ *START-COL* COL) )
+  (AND (EQ *END-ROW* *POINT-ROW*) (> *END-COL* *POINT-COL*)
+    (INCQ *END-COL* COL) ) )
+
+(DEFUN ADJUST-TAB (TAB TEXT-LINE	;Ensure TABs lie on a tab column
+    COL )
+  ((SETQ COL (POSITION *TAB* TEXT-LINE))
+    (SETQ TAB (- 7 (REM TAB 8)))
+    (LOOP
+      ((EQ TAB (REM COL 8))
+	TEXT-LINE )
+      ((ZEROP COL)
+	(MAKE-LIST TAB *BLANK* TEXT-LINE) )
+      ((NEQ *BLANK* (NTH (SUB1 COL) TEXT-LINE))
+	(RPLACD (NTHCDR (SUB1 COL) TEXT-LINE)
+		(MAKE-LIST (REM (+ 8 (- TAB (REM COL 8))) 8) *BLANK*
+				(NTHCDR COL TEXT-LINE)))
+	TEXT-LINE )
+      (RPLACD (RPLACA (NTHCDR (SUB1 COL) TEXT-LINE) *TAB*)
+	      (NTHCDR COL (CDR TEXT-LINE)))
+      (DECQ COL) ) )
+  TEXT-LINE )
+
+
+;	* * *   Screen update functions   * * *
+
+(DEFUN UPDATE-SCRN (
+    ROW ABOVE-POINT BELOW-POINT SCREEN )
+  ( ((IDENTITY *STAT-WINDOW*))
+    (CLEAR-STAT)
+    (SPACES 4)
+    (PRINC *FILE-NAME*)
+    (SPACES (- (TRUNCATE *COLUMNS* 2) 8 (COLUMN)))
+    (WRITE-STRING "  R:C")
+    (SETQ *STAT-RC* (ADD1 (COLUMN)) *STAT-END* *STAT-RC* *STAT-WINDOW* T)
+    (EDIT-WINDOW) )
+  ((LISTEN))
+  (IF (> *CURSOR-COL* *POINT-COL*) (SETQ *CURSOR-COL* *POINT-COL*))
+  (IF (> *CURSOR-ROW* *POINT-ROW*) (SETQ *CURSOR-ROW* *POINT-ROW*))
+  (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*)
+  (SETQ ABOVE-POINT *ABOVE-POINT*  BELOW-POINT *BELOW-POINT*)
+  ( ((NOT *UNPACKED*)
+      (UPDATE-AUX2 *CURSOR-ROW* BELOW-POINT)
+      (POP BELOW-POINT) )
+    (SETQ SCREEN (NTHCDR *CURSOR-ROW* *SCREEN*))
+    (IF (ATOM (CAR SCREEN))
+	(RPLACA SCREEN (NCONC (UNPACK (CAR SCREEN))
+		(MAKE-LIST (- *COLUMNS* (LENGTH (CAR SCREEN))) *BLANK*))) )
+    (SETQ SCREEN (CAR SCREEN))
+    (UPDATE-AUX1 *CURSOR-COL* '+ *RIGHT-POINT*
+		 (NTHCDR *CURSOR-COL* SCREEN))
+    ((LISTEN)
+      (RETURN) )
+    (SETQ SCREEN (NREVERSE SCREEN))
+    (UPDATE-AUX1 (SUB1 *CURSOR-COL*) '- *LEFT-POINT*
+		 (NTHCDR (- *COLUMNS* *CURSOR-COL*) SCREEN))
+    (NREVERSE SCREEN) )
+  (SETQ ROW 0)
+  (LOOP
+    ((LISTEN))
+    (INCQ ROW)
+    ( ((>= (+ *CURSOR-ROW* ROW) *ROWS*))
+      (UPDATE-AUX2 (+ *CURSOR-ROW* ROW) BELOW-POINT)
+      (POP BELOW-POINT) )
+    ( ((< *CURSOR-ROW* ROW))
+      (UPDATE-AUX2 (- *CURSOR-ROW* ROW) ABOVE-POINT)
+      (POP ABOVE-POINT) )
+    ((AND (< *CURSOR-ROW* ROW) (>= (+ *CURSOR-ROW* ROW) *ROWS*))
+      (UPDATE-STAT) ) ) )
+
+(DEFUN UPDATE-AUX1 (COL +- TEXT-LINE LINE
+    NUM )
+  (LOOP
+    ((NOT (SETQ NUM (MISMATCH LINE TEXT-LINE))))
+    ((NULL (SETQ LINE (NTHCDR NUM LINE))))
+    (SETQ TEXT-LINE (NTHCDR NUM TEXT-LINE))
+    (INCQ COL (FUNCALL +- NUM))
+    ((NULL TEXT-LINE)
+      (LOOP
+	((NULL (SETQ NUM (POSITION-IF 'NON-WHITESPACE LINE))))
+	(SET-CURSOR *CURSOR-ROW* (INCQ COL (FUNCALL +- NUM)))
+	(SETQ LINE (NTHCDR NUM LINE))
+	(RPLACA LINE (WRITE-STRING *BLANK*))
+	((LISTEN))
+	(INCQ COL (FUNCALL +- 1))
+	(POP LINE) ) )
+    (SET-CURSOR *CURSOR-ROW* COL)
+    (RPLACA LINE (WRITE-STRING (CAR TEXT-LINE)))
+    ((LISTEN))
+    (INCQ COL (FUNCALL +- 1))
+    (POP LINE)
+    (POP TEXT-LINE) ) )
+
+(DEFUN UPDATE-AUX2 (ROW TEXT-LINE
+    SCREEN )
+  (SETQ SCREEN (NTHCDR ROW *SCREEN*))
+  (IF (CONSP (CAR SCREEN))
+      (RPLACA SCREEN (PACK (TRIM-LINE (CAR SCREEN)))))
+  (SETQ TEXT-LINE (IF TEXT-LINE
+		(SUBSTRING (CAR TEXT-LINE) (- *POINT-COL* *CURSOR-COL*)
+			(+ (- *POINT-COL* *CURSOR-COL*) *COLUMNS* -1))
+		*NUL-STRG*))
+  ((EQ (CAR SCREEN) TEXT-LINE))
+  (SET-CURSOR ROW 0)
+  (SPACES (- (LENGTH (CAR SCREEN)) (LENGTH (WRITE-STRING TEXT-LINE))))
+  (RPLACA SCREEN TEXT-LINE) )
+
+(DEFUN UPDATE-STAT (
+    )
+  ( ((AND *STAT-INS* (EQ *STAT-ROW* *POINT-ROW*) (EQ *STAT-COL* *POINT-COL*))
+      (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*) )
+    (STAT-WINDOW)
+    ( ((IDENTITY *STAT-INS*))
+      (SETQ *STAT-INS* T)
+      (SET-CURSOR 0 (- *COLUMNS* 8))
+      ((NOT *INSERT*)
+	(WRITE-STRING "Replace") )
+      (SETQ *HIGH-INTENSITY* T)
+      (WRITE-STRING "Insert ")
+      (SETQ *HIGH-INTENSITY*) )
+    (SETQ *STAT-ROW* *POINT-ROW* *STAT-COL* *POINT-COL*)
+    (SET-CURSOR 0 *STAT-RC*)
+    (PRINC (ADD1 *STAT-ROW*))
+    (WRITE-STRING '":")
+    (PRINC (ADD1 *STAT-COL*))
+    (SETQ *STAT-END* (PROG1 (COLUMN) (SPACES (- *STAT-END* (COLUMN)))))
+    (EDIT-WINDOW) )
+
+  ((NOT *BLINK-PAREN*))
+  ((NOT *UNPACKED*)
+    ((NULL *BELOW-POINT*))
+    ((EQ (CHAR (CAR *BELOW-POINT*) *POINT-COL*) *LPAR*)
+      (BLINK-RPAR (CAR *BELOW-POINT*) (CDR *BELOW-POINT*)) )
+    ((EQ (CHAR (CAR *BELOW-POINT*) *POINT-COL*) *RPAR*)
+      (BLINK-LPAR (CAR *BELOW-POINT*) *ABOVE-POINT*) ) )
+  ((EQ (CAR *RIGHT-POINT*) *LPAR*)
+    (BLINK-RPAR (PACK* (PACK *LEFT-POINT*) (PACK *RIGHT-POINT*))
+	*BELOW-POINT*) )
+  ((EQ (CAR *RIGHT-POINT*) *RPAR*)
+    (SETQ *LEFT-POINT* (NREVERSE *LEFT-POINT*))
+    (BLINK-LPAR (PACK *LEFT-POINT*) *ABOVE-POINT*)
+    (SETQ *LEFT-POINT* (NREVERSE *LEFT-POINT*)) ) )
+
+(DEFUN BLINK-RPAR (LINE TEXT
+    ROW COL )
+  (SETQ ROW *CURSOR-ROW*  COL *POINT-COL*)
+  ((MATCHING-RPAR 0 T)
+    (DECQ COL)
+    (BLINK-CHAR *RPAR*) ) )
+
+(DEFUN BLINK-LPAR (LINE TEXT
+    ROW COL )
+  (SETQ ROW *CURSOR-ROW*  COL *POINT-COL*)
+  ((MATCHING-LPAR 1 T)
+    (BLINK-CHAR *LPAR*) ) )
+
+(DEFUN BLINK-CHAR (CHAR
+    *BLINK* )
+  (SETQ COL (- COL (- *POINT-COL* *CURSOR-COL*)))
+  ((< -1 COL *COLUMNS*)
+    (SETQ *BLINK* T)
+    (SET-CURSOR ROW COL)
+    (PRINC CHAR)
+    (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*)
+    (LOOP
+      ((LISTEN)) )
+    (SETQ *BLINK*)
+    (SET-CURSOR ROW COL)
+    (PRINC CHAR) ) )
+
+(DEFUN WINDOW-SHAPE ()
+  (START-TEXT)
+  (WINDOW-SHAPE-AUX)
+  (JUMP-LAST) )
+
+(DEFUN WINDOW-SHAPE-AUX (
+    CHAR )
+  (CLEAR-STAT)
+  (SETQ CHAR (PROMPT-READ-CHAR '(F V H | |) " Full, Vertical, Horizontal: "))
+  ((EQ CHAR '| |))
+  (MAKE-WINDOW-SHAPE)
+  (CLEAR-SCREEN)
+  (SETQ *WINDOW-SHAPE* CHAR)
+  (MAKE-SCREEN) )
+
+(DEFUN MAKE-SCREEN (
+    ROW COL MAXROW MAXCOL)
+  (MAKE-WINDOW-SHAPE)
+  (SETQ ROW (CAR (MAKE-WINDOW))
+	COL (CADR (MAKE-WINDOW))
+	MAXROW (CADDR (MAKE-WINDOW))
+	MAXCOL (CADDDR (MAKE-WINDOW))
+	*BASE-ROW* (+ ROW 3)  *BASE-COL* (ADD1 COL)
+	*ROWS* (- MAXROW 4)  *COLUMNS* (- MAXCOL 2)
+	*SCREEN* (MAKE-LIST *ROWS* *NUL-STRG*)
+	*PAGE-ROWS* (CEILING (* *ROWS* 4) 5)
+	*EVAL-ROW* 0
+	*STAT-WINDOW* NIL
+	*HIGH-INTENSITY*)
+  (DECQ MAXROW)
+  (DECQ MAXCOL)
+  (CLEAR-SCREEN)
+  (WRITE-BYTE *NWCORNER*)
+  (WRITE-BYTE *HBORDER* (SUB1 MAXCOL))
+  (WRITE-BYTE *NECORNER*)
+  (SETQ ROW 1)
+  (LOOP
+    (SET-CURSOR ROW 0)
+    ((EQ ROW MAXROW))
+    (WRITE-BYTE *VBORDER*)
+    (SET-CURSOR ROW MAXCOL)
+    (WRITE-BYTE *VBORDER*)
+    (INCQ ROW) )
+  (WRITE-BYTE *SWCORNER*)
+  (WRITE-BYTE *HBORDER* (SUB1 MAXCOL))
+  (WRITE-BYTE *SECORNER*)
+  (SET-CURSOR 2 0)
+  (WRITE-BYTE *LTBORDER*)
+  (WRITE-BYTE *HBORDER* (SUB1 MAXCOL))
+  (WRITE-BYTE *RTBORDER*) )
+
+(DEFUN MAKE-WINDOW-SHAPE ()
+  ((EQ *WINDOW-SHAPE* 'V)
+    (MAKE-WINDOW (CAR *FULL-WINDOW*)
+		 (+ (CADR *FULL-WINDOW*) (CEILING (CADDDR *FULL-WINDOW*) 2))
+		 (CADDR *FULL-WINDOW*)
+		 (FLOOR (CADDDR *FULL-WINDOW*) 2)) )
+  ((EQ *WINDOW-SHAPE* 'H)
+    (MAKE-WINDOW (CAR *FULL-WINDOW*)
+		 (CADR *FULL-WINDOW*)
+		 (+ (FLOOR (CADDR *FULL-WINDOW*) 2) 3)
+		 (CADDDR *FULL-WINDOW*)) )
+  (APPLY 'MAKE-WINDOW *FULL-WINDOW*) )
+
+(DEFUN CLEAR-STAT ()
+  (STAT-WINDOW)
+  (SETQ *STAT-WINDOW* NIL *STAT-ROW* NIL *STAT-COL* NIL *STAT-INS*)
+  (CLEAR-SCREEN) )
+
+(DEFUN STAT-WINDOW ()
+  (MAKE-WINDOW (- *BASE-ROW* 2) *BASE-COL* 1 *COLUMNS*)
+  (SETQ *HIGH-INTENSITY*) )
+
+(DEFUN EDIT-WINDOW ()
+  (MAKE-WINDOW *BASE-ROW* *BASE-COL* *ROWS* *COLUMNS*)
+  (SETQ *HIGH-INTENSITY* T)
+  (SET-CURSOR *CURSOR-ROW* *CURSOR-COL*) )
+
+(DEFUN EVAL-WINDOW ()
+  (SETQ *HIGH-INTENSITY*)
+  ((OR (EQ *WINDOW-SHAPE* 'F)
+       (NEQ 2 (CSMEMORY 855)) )		;IBM PC test
+    (APPLY 'MAKE-WINDOW *FULL-WINDOW*)
+    (SET-CURSOR (SUB1 (CADDR *FULL-WINDOW*)) 0) )
+  ((EQ *WINDOW-SHAPE* 'V)
+    (MAKE-WINDOW (CAR *FULL-WINDOW*)
+		 (CADR *FULL-WINDOW*)
+		 (CADDR *FULL-WINDOW*)
+		 (SUB1 *BASE-COL*))
+    (SET-CURSOR *EVAL-ROW* 0) )
+  (MAKE-WINDOW (+ *ROWS* 4)
+	       (CADR *FULL-WINDOW*)
+	       (- (CADDR *FULL-WINDOW*) *ROWS* 4)
+	       (CADDDR *FULL-WINDOW*))
+  (SET-CURSOR *EVAL-ROW* 0) )
+
+;	* * *   Save edited file functions   * * *
+
+(DEFUN QUIT-EDIT ()
+  ((NOT *TEXT-DIRTY*)
+    (SETQ *FILE-NAME*)
+    (THROW 'QUIT-EDIT) )
+  (CLEAR-STAT)
+  ((PROMPT-Y/N (PACK* " Abandon " *FILE-NAME* '"?"))
+    (SETQ *FILE-NAME*)
+    (THROW 'QUIT-EDIT) ) )
+
+(DEFUN SAVE-FILE ()
+  (SAVE-EDIT)
+  (SETQ *FILE-NAME*)
+  (THROW 'QUIT-EDIT) )
+
+(DEFUN SAVE-EDIT (
+    *SCROLL-FLAG* )
+  (SETQ *SCROLL-FLAG*)
+  (START-TEXT)
+  (PACK-LINE)
+  ((WRITE-FILE *FILE-NAME* (TRIM-TEXT *BELOW-POINT*))
+    (SETQ *TEXT-DIRTY*)
+    (JUMP-LAST) )
+  (JUMP-LAST) )
+
+
+;	* * *   File I/O operation functions   * * *
+
+(DEFUN READ-FILE (FILE-NAME
+    LST ECHO )
+  ((EQ FILE-NAME *NUL-STRG*) NIL)
+  ((RDS FILE-NAME)
+    (CLEAR-STAT)
+    (WRITE-STRING " Reading ")
+    (WRITE-STRING (INPUTFILE))
+    (READPTR 0)
+    (LOOP
+      ((NOT (LISTEN)))
+      (PUSH (READ-LINE) LST) )
+    ( ((EQ *FILE-NAME* FILE-NAME)
+	(SETQ *FILE-NAME* (INPUTFILE)) ) )
+    (RDS)
+    (NREVERSE LST) ) )
+
+(DEFUN WRITE-FILE (FILE-NAME TEXT
+    LINELENGTH ECHO )
+  ((EQ FILE-NAME *NUL-STRG*) NIL)
+  (LOOP
+    ((NULL (WRS FILE-NAME)) NIL)
+    (SETQ WRS)
+    (CLEAR-STAT)
+    (WRITE-STRING " Saving ")
+    (WRITE-STRING (OUTPUTFILE))
+    (SETQ WRS T)
+    (WRITEPTR 0)
+    ((CATCH "Disk Full" (MAPC 'WRITE-LINE TEXT) (WRITE-BYTE 26))
+      (WRS) T)
+    (WRITEPTR 0)
+    (WRS)
+    (CLEAR-STAT)
+    (WRS (FIND "EDIT$.TMP" (OPENFILES) 'FINDSTRING))
+    (WRS)
+    ((OPENFILES) NIL)
+    ((NOT (PROMPT-Y/N " Disk full; retry on new disk?")) NIL) ) )
+
+(DEFUN PRINT-FILE (FILE-NAME
+    ROW LINE WRS LINELENGTH )
+  ((EQ FILE-NAME *NUL-STRG*))
+  ((RDS FILE-NAME)
+    (SETQ ROW 0)
+    (LOOP
+      (CLEAR-STAT)
+      (WRITE-STRING (PACK* " Printing " (INPUTFILE) ", press key to stop "))
+      (LOOP
+	(SETQ RDS NIL WRS)
+	((LISTEN)
+	  (READ-CHAR)
+	  (CLEAR-STAT)
+	  ((PROMPT-Y/N (PACK* " Printing " (INPUTFILE) ", quit?"))
+	    (RDS)
+	    (RETURN) ) )
+	(SETQ RDS T WRS 'PRINT)
+	((NOT (LISTEN))
+	  (PAGE-NUMBER (- *PAGE-LINES* (REM (+ ROW 5) *PAGE-LINES*)))
+	  (RDS)
+	  (RETURN) )
+	( ((ZEROP (REM ROW *PAGE-LINES*))
+	    (INCQ ROW)
+	    (TERPRI) ) )
+	(WRITE-BYTE 32 5)
+	( ((FINDSTRING (ASCII 12) (SETQ LINE (READ-LINE)))
+	    (PAGE-NUMBER (- *PAGE-LINES* (REM (+ ROW 5) *PAGE-LINES*)))
+	    (SETQ LINE (PACK (DELETE (ASCII 12) (UNPACK LINE))))
+	    ((EQ LINE *NUL-STRG*))
+	    (WRITE-LINE LINE)
+	    (INCQ ROW) )
+	  (WRITE-LINE LINE)
+	  (INCQ ROW)
+	  ( ((ZEROP (REM (+ ROW 7) *PAGE-LINES*))
+	      (PAGE-NUMBER 2) ) ) ) ) ) )
+  (CLEAR-SCREEN)
+  (WRITE-STRING FILE-NAME)
+  (WRITE-STRING " not found")
+  (RECLAIM) )
+
+(DEFUN PAGE-NUMBER (NUM)
+  ((ZEROP (REM ROW *PAGE-LINES*)))
+  (TERPRI NUM)
+  (SPACES 36)
+  (PRINC '-)
+  (PRINC (CEILING ROW *PAGE-LINES*))
+  (PRINC '-)
+  (TERPRI 5)
+  (INCQ ROW (+ NUM 5)) )
+
+(DEFUN PROMPT-Y/N (PROMPT)
+  (EQ (PROMPT-READ-CHAR '(Y N | |) (PACK* PROMPT " (Y/N) ")) 'Y) )
+
+(DEFUN PROMPT-READ-CHAR (LST PROMPT
+    READ-CHAR RDS WRS )
+  (WRITE-STRING PROMPT)
+  (PRINC (LOOP
+    ((FIND (STRING-UPCASE (READ-CHAR)) LST)) )) )
+
+(DEFUN PROMPT-FILE (PROMPT
+    FILE-NAME )
+  (SETQ FILE-NAME (STRING-UPCASE (PROMPT-READ-LINE PROMPT)))
+  ((OR (EQ FILE-NAME *NUL-STRG*) (FINDSTRING '\. FILE-NAME)) FILE-NAME)
+  (PACK* FILE-NAME '\. *DEFAULT-TYPE*) )
+
+(DEFUN PROMPT-READ-LINE (PROMPT
+    READ-CHAR RDS WRS )
+  (CLEAR-STAT)
+  (WRITE-STRING PROMPT)
+  (SETQ READ-CHAR T)
+  (CLEAR-INPUT)
+  (READ-LINE) )
+
+(DEFUN TRIM-TEXT (TEXT)
+  (NREVERSE (MEMBER *NUL-STRG* (NREVERSE TEXT) 'NEQ)) )
+
+(DEFUN TRIM-LINE (LINE)
+  (NREVERSE (MEMBER-IF 'NON-WHITESPACE (NREVERSE LINE))) )
+
+(DEFUN BLANK-LINE (LINE)
+  (NOTANY 'NON-WHITESPACE LINE) )
+
+(DEFUN WORD-DELIMITER (CHAR)
+  (MEMBER CHAR *WORD-DELIMITER*) )
+
+(DEFUN WHITESPACE (CHAR)
+  (MEMBER CHAR *WHITESPACE*) )
+
+(DEFUN NON-WHITESPACE (CHAR)
+  (NOT (MEMBER CHAR *WHITESPACE*)) )
+
+(SETQ	*BLANK* '" "
+	*BLINK-PAREN* 'T
+	*DEFAULT-TYPE* 'LSP
+	*MULTIPLE-ESCAPE* '\|
+	*NUL-STRG* '""
+	*PAGE-LINES* 66
+	*LPAR* '\(
+	*RPAR* '\)
+	*SINGLE-ESCAPE* '\\
+	*TAB* (ASCII 9)
+	*WHITESPACE* (LIST *BLANK* *TAB*)
+	*ATOM-DELIMITER* (LIST* *LPAR* *RPAR* *WHITESPACE*)
+	*WORD-DELIMITER* (LIST* '\, '\: '\; *ATOM-DELIMITER*)
+
+	*VBORDER* (ASCII '\|)	;Generic MS-DOS border
+	*HBORDER* (ASCII '\-)
+	*NWCORNER* (ASCII *BLANK*)
+	*NECORNER* (ASCII *BLANK*)
+	*SWCORNER* (ASCII *BLANK*)
+	*SECORNER* (ASCII *BLANK*)
+	*LTBORDER* (ASCII '\|)
+	*RTBORDER* (ASCII '\|) )
+
+(IF (EQ 2 (CSMEMORY 855)) (PROGN	;IBM PC check
+
+(SETQ	*VBORDER* 179			;IBM PC border
+	*HBORDER* 205
+	*NWCORNER* 213
+	*NECORNER* 184
+	*SWCORNER* 212
+	*SECORNER* 190
+	*LTBORDER* 198
+	*RTBORDER* 181)
+
+(PUT (ASCII 255) 'EDIT-CHAR 'EXTENDED)
+
+(DEFUN EXTENDED (
+    CHAR )
+  (SETQ CHAR (READ-CHAR))
+  ((GET CHAR 'EXTENDED)
+    (APPLY (GET CHAR 'EXTENDED)) ) )
+	))
+
+(DEFUN AUTO-EDIT ()
+  (EDIT)
+  (SYSTEM) )
+
+(PROGN
+  (RDS)
+  (TERPRI 2)
+  (IF (EQ 'W (PROMPT-READ-CHAR '(W E)
+		"Make editor Wordstar-like or EMACS-like? (W/E) "))
+      (PROGN
+
+;	* * *	WordStar like editor   * * *
+
+(MAPC '(LAMBDA (PAIR) (PUT (ASCII (- (ASCII (CAR PAIR)) 64))
+			'EDIT-CHAR (CADR PAIR))) '(
+(A LEFT-WORD)
+;B
+(C SCROLL-UP-SCRN)
+(D RIGHT-CHAR)
+(E UP-LINE)
+(F RIGHT-WORD)
+(G DEL-RIGHT-CHAR)
+(H LEFT-CHAR)
+(I RIGHT-TAB)
+(J DOWN-LINE-INDENT)
+(K EDIT-PAIR)
+(L FIND-NEXT)
+(M NEW-LINE)
+(N INSERT-LINE)
+(O EDIT-PAIR)
+(P ESCAPE-CHAR)
+(Q EDIT-PAIR)
+(R SCROLL-DOWN-SCRN)
+(S LEFT-CHAR)
+(T DEL-RIGHT-WORD)
+(U UNDELETE)
+(V INSERT-MODE)
+(W SCROLL-DOWN-LINE)
+(X DOWN-LINE)
+(Y DEL-LINE)
+(Z SCROLL-UP-LINE)
+(\[ EDIT-PAIR) ) )
+
+(PUT (ASCII 127) 'EDIT-CHAR DEL-LEFT-CHAR)
+
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'Q (CADR PAIR))) '(
+(A REPL-STRG)
+(B JUMP-START)
+(C END-TEXT)
+(D RIGHT-END)
+(E TOP-ROW)
+(F FIND-STRG)
+(I LEFT-TAB)
+(K JUMP-END)
+(L REPL-ALL)
+(P JUMP-LAST)
+(R START-TEXT)
+(S LEFT-END)
+(T DEL-LEFT-WORD)
+(V JUMP-FIND)
+(W WINDOW-SHAPE)
+(X BOTTOM-ROW)
+(Y DEL-RIGHT-END) ) )
+
+(PUT (ASCII 127) 'Q 'DEL-LEFT-END)
+
+
+(PUT 'K 'PROMPT " A-abandon D-save S-save/reedit: ")
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'K (CADR PAIR))) '(
+(A QUIT-EDIT)
+(B MARK-START)
+(C COPY-BLOCK)
+(D SAVE-FILE)
+(K MARK-END)
+(Q QUIT-EDIT)
+(R READ-BLOCK)
+(S SAVE-EDIT)
+(V MOVE-BLOCK)
+(W WRITE-BLOCK)
+(Y DEL-BLOCK) ) )
+
+
+(PUT 'O 'PROMPT " BLOCK: Bgn End Mov Cop Del Rd Wr: ")
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'O (CADR PAIR))) '(
+(B MARK-START)
+(C COPY-BLOCK)
+(D DEL-BLOCK)
+(E MARK-END)
+(M MOVE-BLOCK)
+(R READ-BLOCK)
+(W WRITE-BLOCK) ) )
+
+
+(PUT '\[ 'PROMPT " List structure editing command: ")
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) '\[ (CADR PAIR))) '(
+(\! EVAL-SEXP)
+(A LEFT-LIST)
+(C NEXT-DEFN)
+(D RIGHT-SEXP)
+(E LEFT-UP-LIST)
+(F RIGHT-LIST)
+(L EVAL-LISP)
+(R THIS-DEFN)
+(S LEFT-SEXP)
+(T DEL-SEXP)
+(X RIGHT-DOWN-LIST)
+(Y DEL-DEFN)
+(Z RIGHT-UP-LIST) ) )
+
+
+(IF (EQ 2 (CSMEMORY 855))		;IBM PC check
+(PROGN
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'EXTENDED (CADR PAIR))) '(
+(G TOP-ROW)			; Home
+(H UP-LINE)			; Up arrow
+(I SCROLL-DOWN-SCRN)		; PgUp
+(K LEFT-CHAR)			; <--
+(M RIGHT-CHAR)			; -->
+(O BOTTOM-ROW)			; End
+(P DOWN-LINE)			; Down arrow
+(Q SCROLL-UP-SCRN)		; PgDn
+(R INSERT-MODE)			; Ins
+(S DEL-LEFT-CHAR)		; Del
+(\s LEFT-WORD)			; Ctrl <--
+(\t RIGHT-WORD)			; Ctrl -->
+(\u END-TEXT)			; Ctrl-End
+(\v RIGHT-LIST)			; Ctrl-PgDn
+(\w START-TEXT) ) )		; Ctrl-Home
+
+(MAPC '(LAMBDA (PAIR) (PUT (ASCII (CAR PAIR)) 'EXTENDED (CADR PAIR))) '(
+(18 LEFT-UP-LIST)		; Alt-E
+(19 THIS-DEFN)			; Alt-R
+(20 DEL-SEXP)			; Alt-T
+(21 DEL-DEFN)			; Alt-Y
+(30 LEFT-LIST)			; Alt-A
+(31 LEFT-SEXP)			; Alt-S
+(32 RIGHT-SEXP)			; Alt-D
+(33 RIGHT-LIST)			; Alt-F
+(38 EVAL-LISP)			; Alt-L
+(44 RIGHT-UP-LIST)		; Alt-Z
+(45 RIGHT-DOWN-LIST)		; Alt-X
+(46 NEXT-DEFN)			; Alt-C
+(120 EVAL-SEXP)			; Alt-! or Alt-1
+(132 LEFT-LIST) ) )		; Ctrl-PgUp
+
+
+
+) ) ) (PROGN
+
+;	* * *	EMACS like editor   * * *
+
+(DEFUN DEL-RIGHT-LINE ()	;Delete right end of line or NEWLINE
+  (UNPACK-LINE)
+  ((BLANK-LINE *RIGHT-POINT*)
+    (DEL-CRLF) )
+  (DEL-RIGHT-END) )
+
+(MAPC '(LAMBDA (PAIR) (PUT (ASCII (- (ASCII (CAR PAIR)) 64))
+			'EDIT-CHAR (CADR PAIR))) '(
+(@ MARK-START)
+(A LEFT-END)
+(B LEFT-CHAR)
+;C
+(D DEL-RIGHT-CHAR)
+(E RIGHT-END)
+(F RIGHT-CHAR)
+;G
+(H DEL-LEFT-CHAR)
+(I RIGHT-TAB)
+(J DOWN-LINE-INDENT)
+(K DEL-RIGHT-LINE)
+(L FIND-NEXT)
+(M NEW-LINE)
+(N DOWN-LINE)
+(O INSERT-LINE)
+(P UP-LINE)
+(Q ESCAPE-CHAR)
+;R
+(S FIND-STRG)
+;T
+(U EDIT-PAIR)
+(V SCROLL-UP-SCRN)
+(W DEL-BLOCK)
+(X EDIT-PAIR)
+(Y UNDELETE)
+(Z EDIT-PAIR) ) )
+
+(PUT (ASCII 127) 'EDIT-CHAR DEL-LEFT-WORD)
+
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'X (CADR PAIR))) '(
+(< START-TEXT)
+(> END-TEXT)
+(\% REPL-STRG)
+(\2 WINDOW-SHAPE)
+(A QUIT-EDIT)
+(B LEFT-WORD)
+(D DEL-RIGHT-WORD)
+(F RIGHT-WORD)
+(I INSERT-MODE)
+(K DEL-LEFT-END)
+(L REPL-ALL)
+(R READ-BLOCK)
+(S SAVE-EDIT)
+(V SCROLL-DOWN-SCRN)
+(W WRITE-BLOCK) ) )
+
+
+(PUT 'U 'PROMPT " BLOCK: Bgn End Mov Cop Del: ")
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'U (CADR PAIR))) '(
+(B MARK-START)
+(C COPY-BLOCK)
+(D DEL-BLOCK)
+(E MARK-END)
+(M MOVE-BLOCK) ) )
+
+
+(PUT 'Z 'PROMPT " List structure editing command: ")
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'Z (CADR PAIR))) '(
+(\! EVAL-LISP)
+(\( LEFT-UP-LIST)
+(\) RIGHT-UP-LIST)
+(\[ THIS-DEFN)
+(\] NEXT-DEFN)
+(B LEFT-SEXP)
+(D RIGHT-DOWN-LIST)
+(E EVAL-SEXP)
+(F RIGHT-SEXP)
+(K DEL-SEXP)
+(N RIGHT-LIST)
+(P LEFT-LIST) ) )
+
+
+(IF (EQ 2 (CSMEMORY 855))		;IBM PC check
+(PROGN
+
+(MAPC '(LAMBDA (PAIR) (PUT (CAR PAIR) 'EXTENDED (CADR PAIR))) '(
+(G START-TEXT)			; Home
+(H UP-LINE)			; Up arrow
+(I SCROLL-DOWN-SCRN)		; PgUp
+(K LEFT-CHAR)			; <--
+(M RIGHT-CHAR)			; -->
+(O END-TEXT)			; End
+(P DOWN-LINE)			; Down arrow
+(Q SCROLL-UP-SCRN)		; PgDn
+(R INSERT-LINE)			; Ins
+(S DEL-RIGHT-CHAR)		; Del
+(\s LEFT-WORD)			; Ctrl <--
+(\t RIGHT-WORD)			; Ctrl -->
+(\u END-TEXT)			; Ctrl-End
+(\v RIGHT-LIST)			; Ctrl-PgDn
+(\w START-TEXT) ) )		; Ctrl-Home
+
+(MAPC '(LAMBDA (PAIR) (PUT (ASCII (CAR PAIR)) 'EXTENDED (CADR PAIR))) '(
+(17 WRITE-BLOCK)		; Alt-W
+(19 READ-BLOCK)			; Alt-R
+(23 INSERT-MODE)		; Alt-I
+(30 QUIT-EDIT)			; Alt-A
+(31 SAVE-EDIT)			; Alt-S
+(32 DEL-RIGHT-WORD)		; Alt-D
+(33 RIGHT-WORD)			; Alt-F
+(37 DEL-LEFT-END)		; Alt-K
+(47 SCROLL-DOWN-SCRN)		; Alt-V
+(48 LEFT-WORD)			; Alt-B
+(120 EVAL-SEXP)			; Alt-! or Alt-1
+(124 REPL-STRG)			; Alt-%
+(132 LEFT-LIST) ) )		; Ctrl-PgUp
+
+) ) ) )
+
+  (TERPRI 2)
+  (IF (PROMPT-Y/N
+	"Make editor start automatically when the SYS file is loaded?")
+      (SETQ DRIVER 'AUTO-EDIT) )
+  (TERPRI 2)
+  (WRITE-LINE "To save the muLISP editor as a fast loading SYS file on")
+  (WRITE-LINE "the diskette in <drive>, enter a command of the form:")
+  (TERPRI)
+  (WRITE-LINE "          (SAVE 'drive:EDIT)")
+  (TERPRI 2)
+)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/EIGHTS.LSP b/Microsoft muLISP-86 v51/EIGHTS.LSP
new file mode 100644
index 0000000..44f7ede
--- /dev/null
+++ b/Microsoft muLISP-86 v51/EIGHTS.LSP	
@@ -0,0 +1,261 @@
+; File EIGHTS.LSP  (C)		12/29/85	    Soft WareHouse, Inc.
+
+
+;		T h e   E I G H T S   P u z z l e
+
+; EIGHTS searches for the next node using an Ordered State-space
+; search as described in "Principles of Artificial Intelligence", by
+; Nils J. Nilsson, 1980, Tioga Publishing Co., Palo Alto, CA; Pgs 85-88.
+; Program originally written by Mr. Peter A. Harada of Honolulu, Hawaii.
+
+(LOOP (PRINC '*) (EVAL (READ)) ((NULL RDS)) )
+
+(DEFUN EIGHTS (
+    LEGAL-LST RSLT-LST CENTER-COLUMN CHAR)
+  (LOOP
+    (CLEAR-SCREEN)  (TERPRI)
+    (CENTER "* * *   T h e   E I G H T S   P u z z l e   * * *")
+    (TERPRI 2)
+    (WRITE-STRING "Enter in random order the digits 1 through 8 and a space:")
+    (SETQ CENTER-COLUMN (TRUNCATE (CADDDR (MAKE-WINDOW)) 2))
+    (SET-CURSOR 6 (- CENTER-COLUMN 8))   (WRITE-STRING " ----------- ")
+    (SET-CURSOR 7 (- CENTER-COLUMN 8))   (WRITE-STRING "|   |   |   |")
+    (SET-CURSOR 8 (- CENTER-COLUMN 8))   (WRITE-STRING "|---+---+---|")
+    (SET-CURSOR 9 (- CENTER-COLUMN 8))   (WRITE-STRING "|   |   |   |")
+    (SET-CURSOR 10 (- CENTER-COLUMN 8))  (WRITE-STRING "|---+---+---|")
+    (SET-CURSOR 11 (- CENTER-COLUMN 8))  (WRITE-STRING "|   |   |   |")
+    (SET-CURSOR 12 (- CENTER-COLUMN 8))  (WRITE-STRING " ----------- ")
+    (SETQ LEGAL-LST (LIST 1 2 3 4 5 6 7 8 " "))
+    (SETQ RSLT-LST (LIST NIL NIL NIL NIL NIL NIL NIL NIL NIL))
+    (READ-ROW 7 (- CENTER-COLUMN 6) '(0 1 2))
+    (READ-ROW 9 (- CENTER-COLUMN 6) '(7 8 3))
+    (READ-ROW 11 (- CENTER-COLUMN 6) '(6 5))
+    (SET-CURSOR 11 (+ CENTER-COLUMN 2))
+    (SETQ CHAR (CAR LEGAL-LST))
+    ( ((EQ (PRINC CHAR) '" ")
+	(SETQ CHAR 9) ) )
+    (TERPRI 3)
+    (RPLACA (NTHCDR 4 RSLT-LST) CHAR)
+    (EIGHTS-AUX RSLT-LST)
+    ((NOT (Y-OR-N-P "Do you want me to solve another one?"))) ) )
+
+(DEFUN EIGHTS-AUX (START GOAL OPEN CLOSED NODE0 NODEI
+    NODEJ SUCCESSORS NEXPANSIONS N TEMPOPEN)
+  ((NOT (SOLVABLE START))
+    (WRITE-LINE "That is an impossible starting position.")
+    (TERPRI) )
+  (SETQ NODE0 START)
+  (SETQ GOAL '(1 2 3 4 5 6 7 8 9))
+  (SETQ N (SETQ NEXPANSIONS 0))
+  (SETQ OPEN (LIST (LIST (F* NODE0 N) N NODE0 NIL)))
+  (LOOP
+    (PRINC '*)
+    (SETQ OPEN (APPEND TEMPOPEN OPEN))
+    (SETQ OPEN (DELETE (SETQ NODEI (GET-MIN-NODE OPEN GOAL)) OPEN 'EQUAL))
+    (PUSH NODEI CLOSED)
+    ((EQUAL (CADDR NODEI) GOAL)
+      (OUTPUT-SOLUTION START NODEI CLOSED NEXPANSIONS) )
+    (SETQ SUCCESSORS (EXPAND-NODE (CADDR NODEI)))
+    (SETQ N (ADD1 (CADR NODEI)))
+    (SETQ TEMPOPEN NIL)
+    (LOOP
+      ((NULL SUCCESSORS))
+      (INCQ NEXPANSIONS)
+      (SETQ NODEJ (LIST (F* (CAR SUCCESSORS) N) N (CAR SUCCESSORS)
+			(CADDR NODEI)))
+      (SETQ INOPEN (CONTAINED-INP OPEN NODEJ))
+      (SETQ INCLOSED (CONTAINED-INP CLOSED NODEJ))
+      ( ((AND (NULL INOPEN) (NULL INCLOSED))
+	  (PUSH NODEJ TEMPOPEN) )
+	((AND (NULL INOPEN) (< (CAR NODEJ) (CAR INCLOSED)))
+	  (SETQ CLOSED (DELETE (GET-MIN-NODE CLOSED (CADDR NODEJ))
+		CLOSED 'EQUAL))
+	  (PUSH NODEJ TEMPOPEN) )
+	((AND (NULL INCLOSED) (< (CAR NODEJ) (CAR INOPEN)))
+	  (SETQ OPEN (DELETE (GET-MIN-NODE OPEN (CADDR NODEJ)) OPEN 'EQUAL))
+	  (PUSH NODEJ TEMPOPEN) ) )
+      (POP SUCCESSORS) ) ) )
+
+(DEFUN CONTAINED-INP (LST NODE TEMP)
+  (SETQ NODE (CADDR NODE))
+  (LOOP
+    ((NULL LST) NIL)
+    (SETQ TEMP (POP LST))
+    ((EQUAL (CADDR TEMP) NODE) TEMP) ) )
+
+(DEFUN EXPAND-NODE (NODE)
+  (MAPCAR 'XCHG-POS (NTH (POSITION 9 NODE) MOVE-LIST)) )
+
+(DEFUN XCHG-POS (PAIR LST TEMP1 TEMP2)
+  (SETQ LST (COPY-LIST NODE))
+  (SETQ TEMP1 (NTHCDR (CAR PAIR) LST))
+  (SETQ TEMP2 (NTHCDR (CADR PAIR) LST))
+  (SETQ TEMP (CAR TEMP2))
+  (RPLACA TEMP2 (CAR TEMP1))
+  (RPLACA TEMP1 TEMP)  LST )
+
+(SETQ MOVE-LIST '(((0 1) (0 7))		((0 1) (1 2) (1 8))
+		  ((1 2) (2 3))		((3 8) (2 3) (3 4))
+		  ((4 5) (3 4))		((5 6) (4 5) (5 8))
+		  ((5 6) (6 7))		((7 8) (0 7) (6 7))
+		  ((7 8) (3 8) (1 8) (5 8)) ) )
+
+(SETQ POS-LIST '((0 1 2 3 4 3 2 1 0)	(1 0 1 2 3 2 3 2 0)
+		 (2 1 0 1 2 3 4 3 0)	(3 2 1 0 1 2 3 2 0)
+		 (4 3 2 1 0 1 2 3 0)	(3 2 3 2 1 0 1 2 0)
+		 (2 3 4 3 2 1 0 1 0)	(1 2 3 2 3 2 1 0 0)
+		 (2 1 2 1 2 1 2 1 0) ) )
+
+(DEFUN F* (LAYOUT N)
+  (+ N (H* LAYOUT N)) )
+
+(DEFUN H* (LAYOUT N PWEIGHT SWEIGHT)
+  (SETQ PWEIGHT 1)  (SETQ SWEIGHT 3)		; Adjustable weights
+  (+ (* PWEIGHT (P* LAYOUT N)) (* SWEIGHT (S* LAYOUT N))))
+
+(DEFUN P* (LAYOUT N SUM POSITION)
+  (SETQ SUM 0)
+  (SETQ POSITION POS-LIST)
+  (LOOP
+    ((NULL LAYOUT) SUM)
+    (INCQ SUM (NTH (+ (POP LAYOUT) -1) (POP POSITION))) ) )
+
+(DEFUN S* (LAYOUT N
+    SUM NUM)
+  (SETQ SUM 1)
+  ( ((EQ (CAR LAYOUT) 9)
+      (SETQ LAYOUT (COPY-LIST (CDR LAYOUT))) )
+    ((EQ (CAR (LAST LAYOUT)) 9)
+      (SETQ SUM 0)
+      (SETQ LAYOUT (COPY-LIST LAYOUT)) )
+    (SETQ LAYOUT (REMOVE 9 LAYOUT)) )
+  (RPLACA (LAST LAYOUT) (CAR LAYOUT))
+  (LOOP
+    (SETQ NUM (POP LAYOUT))
+    ((NULL LAYOUT) SUM)
+    ( ((EQ NUM 8)
+	((EQ (CAR LAYOUT) 1))
+	(INCQ SUM 2) )
+      ((EQ (ADD1 NUM) (CAR LAYOUT)))
+      (INCQ SUM 2) ) ) )
+
+(DEFUN GET-MIN-NODE (NODE-LST CONSTANT
+    MIN-NODE)
+  (SETQ MIN-NODE (POP NODE-LST))
+  (LOOP
+    ((NULL NODE-LST) MIN-NODE)
+    (SETQ NODE (POP NODE-LST))
+    ((EQUAL (CADDR NODE) CONSTANT) NODE)
+    ( ((> (CAR MIN-NODE) (CAR NODE))
+	(SETQ MIN-NODE NODE) )
+      ((AND (EQUAL (CAR MIN-NODE) (CAR NODE))
+	    (> (CADR MIN-NODE) (CADR NODE)) )
+	(SETQ MIN-NODE NODE) ) ) ) )
+
+; SOLVABLE's algorthm is from "Mathematical Games and Pastimes"
+; by A. P. Domoryad; Macmillan Co., 1964, Pgs 79-85.
+
+(DEFUN SOLVABLE (LST
+    FLAG)
+  (MAPC '(LAMBDA (NUM) (DISORDER NUM LST)) LST)
+  (EQ (NOT FLAG) (EVENP (POSITION 9 LST))) )
+
+(DEFUN DISORDER (NUM LST)
+  ((EQ NUM (CAR LST)))
+  ((> (CAR LST) NUM)
+    (SETQ FLAG (NOT FLAG))
+    (DISORDER NUM (CDR LST)) )
+  (DISORDER NUM (CDR LST)) )
+
+
+(DEFUN OUTPUT-SOLUTION (START LASTNODE LST EXPANSIONS
+    LST1 PRINTLIST)
+  (TERPRI 2)
+  (WRITE-STRING "The number of moves checked was ")  (PRINC EXPANSIONS)
+  (WRITE-LINE " and the shortest sequence is:")  (TERPRI)
+  (LOOP
+    (PUSH (CADDR LASTNODE) PRINTLIST)
+    (SETQ LST1 LST)
+    (LOOP
+      ((EQUAL (CAR (CDDDR LASTNODE)) (CADDR (CAR LST1)))
+	(SETQ LASTNODE (CAR LST1)) )
+      (POP LST1) )
+    ((NULL (CAR (CDDDR LASTNODE)))
+      (FORMAT-OUTPUT (PUSH START PRINTLIST)) ) ) )
+
+(DEFUN FORMAT-OUTPUT (ANSWERS DISPLAY# S1 S2 S3 COUNTER)
+  (SETQ DISPLAY# (TRUNCATE (+ 2 (LINELENGTH)) 7))
+  (LOOP				; Prints DISPLAY# of squares
+    ((NULL (CAR ANSWERS)))	; across the page from a list
+    (SETQ COUNTER 0)		; of lists in ANSWERS
+    (SETQ S1)
+    (LOOP
+      ((EQUAL COUNTER DISPLAY#))
+      (SETQ S2 (POP ANSWERS))
+      ((NULL S2))
+      (PUSH S2 S1)
+      (INCQ COUNTER) )
+    (SETQ DISPLAY# COUNTER)
+    (SETQ S1 (REVERSE S1))
+    (PRINT-ROW S1 DISPLAY# '(0 1 2))
+    (PRINT-ROW S1 DISPLAY# '(7 8 3))
+    (PRINT-ROW S1 DISPLAY# '(6 5 4))
+    (TERPRI) ) )
+
+(DEFUN PRINT-ROW (LST DISPLAY# INDEX-LIST)
+  (LOOP
+    ((ZEROP DISPLAY#) (TERPRI))
+    (PRIN3 (NTH (CAR INDEX-LIST) (CAR LST)))
+    (PRIN3 (NTH (CADR INDEX-LIST) (CAR LST)))
+    (PRIN3 (NTH (CADDR INDEX-LIST) (POP LST)))
+    (SPACES 1)
+    (DECQ DISPLAY#) ) )
+
+(DEFUN PRIN3 (NUM)
+  ((EQ NUM 9)
+    (WRITE-STRING "  ") )
+  (PRINC NUM)
+  (SPACES 1) )
+
+(DEFUN READ-ROW (ROW COL LST
+    READ-CHAR)
+  (LOOP
+    (SET-CURSOR ROW COL)
+    (LOOP
+      (SETQ CHAR (READ-CHAR))
+      ((EQ CHAR (ASCII 3))		;Abort EIGHTS if <CTRL-C> typed
+	(THROW) )
+      ( ((EQ CHAR '" "))
+	(SETQ CHAR (- (ASCII CHAR) 48)) )
+      ((MEMBER CHAR LEGAL-LST))
+      (PRINC (ASCII 7)) )
+    (SETQ LEGAL-LST (REMOVE CHAR LEGAL-LST))
+    ( ((EQ (PRINC CHAR) '" ")
+	(SETQ CHAR 9) ) )
+    (RPLACA (NTHCDR (POP LST) RSLT-LST) CHAR)
+    ((NULL LST))
+    (INCQ COL 4) ) )
+
+(DEFUN CENTER (MSG)
+  (SET-CURSOR (ROW)
+	(TRUNCATE (- (CADDDR (MAKE-WINDOW)) (LENGTH MSG)) 2))
+  (WRITE-LINE MSG) )
+
+(DEFUN Y-OR-N-P (MSG
+    CHAR READ-CHAR RDS WRS )
+  ( ((NULL MSG))
+    (FRESH-LINE)
+    (WRITE-STRING (PACK* MSG " (Y/N) ")) )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    ((EQ CHAR 'Y)
+      (WRITE-LINE CHAR)
+      T )
+    ((EQ CHAR 'N)
+      (WRITE-LINE CHAR)
+      NIL )
+    (WRITE-BYTE 7) ) )
+
+(EIGHTS (RDS))
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/GRAPHICS.LSP b/Microsoft muLISP-86 v51/GRAPHICS.LSP
new file mode 100644
index 0000000..20eff5d
--- /dev/null
+++ b/Microsoft muLISP-86 v51/GRAPHICS.LSP	
@@ -0,0 +1,220 @@
+;File:  GRAPHICS.LSP  (c)	12/27/85	Soft Warehouse, Inc.
+
+
+; This file contains the graphics functions defined in muLISP Lesson #6.
+
+(SETQ COLUMNS 80)	; Number of columns on your screen.
+
+(SETQ ROWS 24)		; Number of rows on your screen.
+
+; DOT is the character graphics primitive function.  It requires that
+; (SET-CURSOR row column) be properly defined for your computer and terminal.
+
+(DEFUN DOT (X-COORD Y-COORD
+    LINELENGTH )
+  ((AND (< (- X-MAX) X-COORD X-MAX)
+	(< (- Y-MAX) Y-COORD Y-MAX) )
+    (SET-CURSOR (- Y-MAX Y-COORD) (+ X-MAX X-COORD))
+    (PRIN1 DOT) ) )
+
+(SETQ X-MAX (TRUNCATE (ADD1 COLUMNS) 2))
+
+(SETQ Y-MAX (TRUNCATE (ADD1 ROWS) 2))
+
+(SETQ DOT '*)
+
+(DEFUN DRAW (NLAMBDA COMMANDS
+  (CLEAR-SCREEN)
+  (MAPC 'EVAL COMMANDS)
+  (SET-CURSOR 0 0) ))
+
+(DEFUN LINE (X1 Y1 X2 Y2
+    DELTA-X DELTA-Y SIGN-DELTA-X SIGN-DELTA-Y)
+  (SETQ DELTA-X (- X2 X1)
+	DELTA-Y (- Y2 Y1)
+	SIGN-DELTA-X (SIGNUM DELTA-X)
+	SIGN-DELTA-Y (SIGNUM DELTA-Y)
+	DELTA-X (ABS DELTA-X)
+	DELTA-Y (ABS DELTA-Y))
+  ((< DELTA-Y DELTA-X)
+    (SETQ DELTA-Y (+ DELTA-Y DELTA-Y)		;Gentle slope
+	  Y2 (- DELTA-Y DELTA-X)
+	  DELTA-X (- DELTA-X Y2))
+    (LOOP
+      (DOT X1 Y1)
+      ((EQ X1 X2))
+      ( ((PLUSP Y2)
+	  (INCQ Y1 SIGN-DELTA-Y)
+	  (DECQ Y2 DELTA-X) )
+	(INCQ Y2 DELTA-Y) )
+      (INCQ X1 SIGN-DELTA-X) ) )
+  (SETQ DELTA-X (+ DELTA-X DELTA-X)		;Steep slope
+	X2 (- DELTA-X DELTA-Y)
+	DELTA-Y (- DELTA-Y X2))
+  (LOOP
+    (DOT X1 Y1)
+    ((EQ Y1 Y2))
+    ( ((PLUSP X2)
+	(INCQ X1 SIGN-DELTA-X)
+	(DECQ X2 DELTA-Y) )
+      (INCQ X2 DELTA-X) )
+    (INCQ Y1 SIGN-DELTA-Y) ) )
+
+
+(DEFUN REDUCED-SIN (DEG)
+  (/ (* DEG (+ 1324959969 (* (SETQ DEG (* DEG DEG)) (+ -67245 DEG))))
+     75914915920) )
+
+(DEFUN REDUCED-COS (DEG)
+  (SETQ DEG (* DEG DEG))
+  (/ (+ 266153374 (* DEG (+ -40518 DEG)))
+     266153374) )
+
+(DEFUN SIN-DEG (ANGLE)
+  ((MINUSP ANGLE)
+    (SETQ ANGLE (DIVIDE (REM (- ANGLE) 360) 45))
+    (- (SIN-COS-DEG (CAR ANGLE) (CDR ANGLE))) )
+  (SETQ ANGLE (DIVIDE (REM ANGLE 360) 45))
+  (SIN-COS-DEG (CAR ANGLE) (CDR ANGLE)) )
+
+(DEFUN COS-DEG (ANGLE)
+  (SETQ ANGLE (DIVIDE (REM (ABS ANGLE) 360) 45))
+  (SIN-COS-DEG (+ 2 (CAR ANGLE)) (CDR ANGLE)) )
+
+(DEFUN SIN-COS-DEG (N45DEG RESID)
+  ((> N45DEG 3)
+    (- (SIN-COS-DEG (- N45DEG 4) RESID)) )
+  ((ZEROP N45DEG) (REDUCED-SIN RESID))
+  ((EQL N45DEG 1) (REDUCED-COS (- 45 RESID)))
+  ((EQL N45DEG 2) (REDUCED-COS RESID))
+  (REDUCED-SIN (- 45 RESID)) )
+
+
+(DEFUN SETPOS (X Y)
+  (SETQ X-POS X  Y-POS Y) )
+
+(DEFUN TURN (ANGLE)
+  (SETQ HEADING (REM (+ HEADING ANGLE) 360)) )
+
+(DEFUN SETHEADING (ANGLE)
+  (SETQ HEADING (REM ANGLE 360)) )
+
+(DEFUN PENDOWN ()
+  (SETQ PENDOWN T) )
+
+(DEFUN PENUP ()
+  (SETQ PENDOWN NIL) )
+
+
+(DEFUN TURTLE (NLAMBDA COMMANDS
+  (SETPOS 0 0)
+  (SETHEADING 0)
+  (PENDOWN)
+  (APPLY 'DRAW COMMANDS) ))
+
+(DEFUN FORWARD (DISTANCE
+    X-OLD Y-OLD )
+  (SETQ X-OLD X-POS)
+  (SETQ Y-OLD Y-POS)
+  (INCQ X-POS (ROUND (* DISTANCE (SIN-DEG HEADING))))
+  (INCQ Y-POS (ROUND (* DISTANCE (COS-DEG HEADING))))
+  ((NOT PENDOWN))
+  (LINE X-OLD Y-OLD X-POS Y-POS) )
+
+(DEFUN FORWARD-THEN-TURN (DISTANCE ANGLE)
+  (FORWARD DISTANCE)
+  (TURN ANGLE) )
+
+
+(DEFUN POLY (SIDE ANGLE
+    TOT-TURN)
+  (SETQ TOT-TURN 0)
+  (LOOP
+    (FORWARD-THEN-TURN SIDE ANGLE)
+    (SETQ TOT-TURN (REM (+ TOT-TURN ANGLE) 360))
+    ((ZEROP TOT-TURN)) ) )
+
+(DEFUN CORN-POL (SIDE ANGLE
+    TOT-TURN)
+  ((> SIDE 1)
+    (SETQ TOT-TURN 0)
+    (LOOP
+      (FORWARD SIDE)
+      (CORN-POL (SHIFT SIDE -2) (- ANGLE))
+      (TURN ANGLE)
+      (SETQ TOT-TURN (REM (+ TOT-TURN ANGLE) 360))
+      ((ZEROP TOT-TURN)) ) ) )
+
+(DEFUN SPIRAL (SIDE ANGLE INCR)
+  (LOOP
+    ((< SIDE INCR))
+    (FORWARD-THEN-TURN SIDE ANGLE)
+    (DECQ SIDE INCR) ) )
+
+(DEFUN SPIROLAT (SIDE ANGLE INCR
+    TOT-TURN)
+  (SETQ TOT-TURN 0)
+  (LOOP
+     (SPIRAL SIDE ANGLE INCR)
+     (SETQ TOT-TURN (REM (+ TOT-TURN (* ANGLE (TRUNCATE SIDE INCR))) 360))
+     ((ZEROP TOT-TURN)) ) )
+
+(DEFUN IBM-DOT (X-COORD Y-COORD)
+  ((AND (< -161 X-COORD 160)
+	(< -101 Y-COORD 100) )
+    (REGISTER 2 (+ 160 X-COORD))
+    (REGISTER 3 (- 100 Y-COORD))
+    (REGISTER 0 *COLOR*)
+    (INTERRUPT 16) ) )
+
+(MOVD 'IBM-DOT 'DOT)		;Use IBM plot dot routine
+
+(DEFUN SETCOLOR (COLOR)
+  (SETQ *COLOR* (+ 3071 (LENGTH (MEMBER COLOR
+	'(WHITE RED GREEN BLACK))))) )
+
+(SETCOLOR WHITE)
+
+(DEFUN GRAPHICS-MODE ()		;Sets up 320 x 200 color graphics mode
+  (REGISTER 0 4)
+  (INTERRUPT 16)
+  (MAKE-WINDOW 0 0 25 40) )
+
+(DEFUN ALPHA-MODE ()		;Sets up 25 x 80 color alpha mode
+  (REGISTER 0 3)
+  (INTERRUPT 16)
+  (CURSOR-LINES NIL)
+  (MAKE-WINDOW 0 0 25 80) )
+
+(DEFUN TURTLE (NLAMBDA COMMANDS
+  (IF (NEQ (CADDDR (MAKE-WINDOW)) 40) (GRAPHICS-MODE) )
+  (MAKE-WINDOW 0 0 21 40)
+  (SETPOS 0 0)
+  (SETHEADING 0)
+  (PENDOWN)
+  (CATCH 'DRIVER (APPLY 'DRAW COMMANDS))
+  (MAKE-WINDOW 21 0 4 40)
+  (SET-CURSOR 3 0) ))
+
+(DEFUN C-CURVE (DEPTH)		;"C" curve function
+  ((ZEROP DEPTH)
+    (FORWARD *LENGTH*) )
+  (TURN 45)
+  (C-CURVE (SUB1 DEPTH))
+  (TURN -90)
+  (C-CURVE (SUB1 DEPTH))
+  (TURN 45) )
+
+(SETQ *LENGTH* 3)
+
+(DEFUN D-CURVE (DEPTH FLAG)	;"Dragon" curve function
+  ((ZEROP DEPTH)
+    (FORWARD *LENGTH*) )
+  (IF FLAG (TURN 45) (TURN -45))
+  (D-CURVE (SUB1 DEPTH) T)
+  (IF FLAG (TURN -90) (TURN 90))
+  (D-CURVE (SUB1 DEPTH) NIL)
+  (IF FLAG (TURN 45) (TURN -45)) )
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/HANOI.LSP b/Microsoft muLISP-86 v51/HANOI.LSP
new file mode 100644
index 0000000..e95e387
--- /dev/null
+++ b/Microsoft muLISP-86 v51/HANOI.LSP	
@@ -0,0 +1,145 @@
+; File:  HANOI.LSP  (c)		12/29/85	Soft Warehouse, Inc.
+
+
+;		* * *   The Tower of Hanoi Puzzle   * * *
+
+(LOOP (PRIN1 (QUOTE *)) (EVAL (READ)) ((NULL RDS)) )
+
+(SETQ *BLOCK-CHAR* (ASCII 219))		; Character used to make rings
+
+(DEFUN HANOI (
+    *RINGS* *HIGH-SPEED* *COLOR* *TONE* *TIME* *ROWS* MAX-RINGS
+    PEG1-RINGS PEG2-RINGS PEG3-RINGS PEG1-COLUMN PEG2-COLUMN PEG3-COLUMN
+    *AUTO-NEWLINE* )
+  (SETQ *ROWS* (CADDR (MAKE-WINDOW)))
+  (LOOP
+    (SETQ *TIME* 120)
+    (CLEAR-SCREEN)
+    (SETQ *HIGH-INTENSITY* T)
+    (CENTER "T H E   T O W E R   O F   H A N O I")
+    (SETQ *HIGH-INTENSITY*)
+    (CLEAR-INPUT)
+    (TERPRI 2)
+    (SETQ MAX-RINGS (MIN
+	(TRUNCATE (SUB1 (TRUNCATE (CADDDR (MAKE-WINDOW)) 2)) 3)
+	(SUB1 (CADDR (MAKE-WINDOW))) ))
+    (LOOP
+      (WRITE-STRING (PACK* "   Number of rings to use (1 to " MAX-RINGS ")? "))
+      ((AND
+	(SETQ *RINGS* (SYMBOL-TO-INTEGER (READ-LINE)))
+	(<= 1 *RINGS* MAX-RINGS))) )
+    (TERPRI)
+    (SETQ *HIGH-SPEED* (NOT (Y-OR-N-P "  Run program at normal speed?")))
+    ( ((NOT *HIGH-SPEED*)
+	(TERPRI)
+	(SETQ *TONE* (Y-OR-N-P "    Do you want sound effects?")) ) )
+    (TERPRI)
+    (SETQ *COLOR* (Y-OR-N-P "Are you using a color monitor?"))
+    (CLEAR-SCREEN)
+    (SETQ *HIGH-INTENSITY* T)
+    (CENTER "T H E   T O W E R   O F   H A N O I")
+    (SETQ *HIGH-INTENSITY*)
+    (PUT 'PEG2 'COLUMN (TRUNCATE (CADDDR (MAKE-WINDOW)) 2))
+    (PUT 'PEG1 'COLUMN (- (GET PEG2 'COLUMN) *RINGS* *RINGS* 1))
+    (PUT 'PEG3 'COLUMN (+ (GET PEG2 'COLUMN) *RINGS* *RINGS* 1))
+    (PRINT-PEG *RINGS* *ROWS* (GET 'PEG1 'COLUMN))
+    (PRINT-PEG *RINGS* *ROWS* (GET 'PEG2 'COLUMN))
+    (PRINT-PEG *RINGS* *ROWS* (GET 'PEG3 'COLUMN))
+    (PUT PEG1 'RINGS (MAKE-TOWER *RINGS* *ROWS* (GET 'PEG1 'COLUMN)))
+    (PUT PEG2 'RINGS NIL)
+    (PUT PEG3 'RINGS NIL)
+    (UNWIND-PROTECT (MOVE-RINGS *RINGS* 'PEG1 'PEG2 'PEG3)
+      (FOREGROUND-COLOR 7) )
+    (SET-CURSOR 2 0)
+    ((NOT (Y-OR-N-P "Run the puzzle again?"))) ) )
+
+(DEFUN MOVE-RINGS (RINGS SOURCE-PEG TARGET-PEG SPARE-PEG
+    SOURCE-RINGS )
+  ((ZEROP RINGS))
+  (MOVE-RINGS (SUB1 RINGS) SOURCE-PEG SPARE-PEG TARGET-PEG)
+  (SETQ SOURCE-RINGS (GET SOURCE-PEG 'RINGS))
+  (PUT TARGET-PEG 'RINGS (CONS (CAR SOURCE-RINGS) (GET TARGET-PEG 'RINGS)))
+  (PUT SOURCE-PEG 'RINGS (CDR SOURCE-RINGS))
+  (SET-CURSOR (- *ROWS* (LENGTH SOURCE-RINGS))
+	      (- (GET SOURCE-PEG 'COLUMN) (CAAR SOURCE-RINGS)))
+  (SPACES (CAAR SOURCE-RINGS))
+  (PRINC *BLOCK-CHAR*)
+  (SPACES (CAAR SOURCE-RINGS))
+  (IF *COLOR* (FOREGROUND-COLOR (CAAR SOURCE-RINGS)))
+  ( ((IDENTITY *HIGH-SPEED*))
+    (PRINT-RING (CAAR SOURCE-RINGS) (CDAR SOURCE-RINGS) SOURCE-PEG *TIME*)
+    (IF (OR (EQ SOURCE-PEG 'PEG2) (EQ TARGET-PEG 'PEG2)) NIL
+	(PRINT-RING (CAAR SOURCE-RINGS) (CDAR SOURCE-RINGS) 'PEG2 *TIME*) )
+    (PRINT-RING (CAAR SOURCE-RINGS) (CDAR SOURCE-RINGS) TARGET-PEG *TIME*) )
+  (SET-CURSOR (- *ROWS* (LENGTH (GET TARGET-PEG 'RINGS)))
+	      (- (GET TARGET-PEG 'COLUMN) (CAAR SOURCE-RINGS)))
+  (PRINC (CDAR SOURCE-RINGS))
+  (IF *COLOR* (FOREGROUND-COLOR 7))
+  (IF *HIGH-SPEED* NIL (TONE NIL *TIME*))
+; (IF (> *TIME* 10) (DECQ *TIME*))		;Optional accelerator
+  (MOVE-RINGS (SUB1 RINGS) SPARE-PEG TARGET-PEG SOURCE-PEG) )
+
+(DEFUN PRINT-RING (RING-SIZE RING-STRING PEG TIME)
+  ((SET-CURSOR (- *ROWS* *RINGS* 3) (- (GET PEG 'COLUMN) RING-SIZE))
+    (WRITE-STRING RING-STRING)
+    (SET-CURSOR (- *ROWS* *RINGS* 3) (- (GET PEG 'COLUMN) RING-SIZE))
+    (TONE (IF *TONE* (CDR (ASSOC (CAAR SOURCE-RINGS) *NOTES*))) TIME)
+    (SPACES (ADD1 (* 2 RING-SIZE))) )
+  (TONE (IF *TONE* (CDR (ASSOC (CAAR SOURCE-RINGS) *NOTES*))) TIME) )
+
+(SETQ *NOTES* '((1 . 523) (2 . 494) (3 . 440) (4 . 392) (5 . 349) (6 . 330)
+	(7 . 294) (8 . 262) (9 . 247) (10 . 220) (11 . 196) (12 . 175)
+	(13 . 165) (14 . 147) (15 . 131)))
+
+(DEFUN PRINT-PEG (RINGS ROW COLUMN)
+  (LOOP
+    (SET-CURSOR (DECQ ROW) COLUMN)
+    (PRINC *BLOCK-CHAR*)
+    ((ZEROP RINGS))
+    (DECQ RINGS) ) )
+
+(DEFUN MAKE-TOWER (RINGS ROW COLUMN
+    PEG-RINGS )
+  (LOOP
+    ((ZEROP RINGS)
+      (IF *COLOR* (FOREGROUND-COLOR 7))
+      PEG-RINGS )
+    (PUSH (CONS RINGS (PACK (MAKE-LIST (ADD1 (* 2 RINGS)) *BLOCK-CHAR*)))
+	  PEG-RINGS)
+    (SET-CURSOR (DECQ ROW) (- COLUMN RINGS))
+    (IF *COLOR* (FOREGROUND-COLOR RINGS))
+    (PRINC (CDAR PEG-RINGS))
+    (DECQ RINGS) ) )
+
+(DEFUN CENTER (MSG)
+  (SET-CURSOR (ROW)
+	(TRUNCATE (- (CADDDR (MAKE-WINDOW)) (LENGTH MSG)) 2))
+  (WRITE-LINE MSG) )
+
+(DEFUN SYMBOL-TO-INTEGER (SYMBOL
+    NUM )
+  ((SETQ SYMBOL (UNPACK SYMBOL))
+    (SETQ NUM 0)
+    (LOOP
+      ((NOT (<= 48 (ASCII (CAR SYMBOL)) 57)) NIL)
+      (SETQ NUM (+ (* NUM 10) (- (ASCII (POP SYMBOL)) 48)))
+      ((NULL SYMBOL) NUM) ) ) )
+
+(DEFUN Y-OR-N-P (MSG
+    CHAR READ-CHAR RDS WRS )
+  ( ((NULL MSG))
+    (FRESH-LINE)
+    (WRITE-STRING (PACK* MSG " (Y/N) ")) )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    ((EQ CHAR 'Y)
+      (WRITE-LINE CHAR)
+      T )
+    ((EQ CHAR 'N)
+      (WRITE-LINE CHAR)
+      NIL )
+    (WRITE-BYTE 7) ) )
+
+(HANOI (RDS))
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/HELP.LSP b/Microsoft muLISP-86 v51/HELP.LSP
new file mode 100644
index 0000000..dc33e7c
--- /dev/null
+++ b/Microsoft muLISP-86 v51/HELP.LSP	
@@ -0,0 +1,484 @@
+; File:	HELP.LSP  (C)		12/28/85	Soft Warehouse, Inc.
+
+;			muLISP Help Facility
+
+; To use the Help Facility, read this file into muLISP using the RDS
+; command: (RDS HELP).  Then if <name> is the name of a muLISP primitive,
+; the command (HELP 'name) displays <name>'s arguments or initial value
+; and <name>'s page number in Chapter 5 of the muLISP Reference Manual.
+
+
+(PROG1
+
+(DEFUN HELP (NAME
+    READ-CHAR RDS WRS )
+  (SETQ READ-CHAR 0)
+  (LOOP
+    (FRESH-LINE)
+    ((GET NAME 'HELP-POINTER)
+      ((RDS *HELP-FILE*)
+	(READPTR (GET NAME 'HELP-POINTER))
+	(WRITE-LINE (READ-LINE))
+	T )
+      (WRITE-LINE (PACK* *HELP-FILE* "not found"))
+      NIL )
+    (WRITE-STRING "Enter primitive name: ")
+    (CLEAR-INPUT)
+    (SETQ NAME (STRING-UPCASE (READ-LINE)))
+    ((EQ NAME '||)) ) )
+
+(MOVD 'HELP '?)
+
+(SETQ *HELP-FILE* (INPUTFILE))
+
+(LOOP
+  ((NOT (LISTEN))
+    (TERPRI 2)
+    (WRITE-LINE
+      "For help on the muLISP primitive <name>, enter:  (HELP name)")
+    (SETQ RDS) )
+  ((LAMBDA (NUM LINE)
+      ((EQ LINE ||))
+      (PUT (STRING-RIGHT-TRIM |: | (SUBSTRING LINE 0 (FINDSTRING '| | LINE)))
+	   'HELP-POINTER NUM))
+    (READPTR)
+    (READ-LINE)) ) )
+
+ABS [n]				Numerical	Function	139
+ACONS [key, object, alist]	Constructor	Function	36
+ACOS [n]			Numerical	Function	137
+ADD1 [n]			Numerical	Function	126
+ADJOIN [object, list, test]	Constructor	Function	33
+ALLOCATE [n]			Memory		Function	236
+ALPHA-CHAR-P [symbol]		Character	Function	90
+ALPHANUMERICP [symbol]		Character	Function	90
+AND [form1, ... formn]		Logical		Special form	66
+APPEND [list1, ... listn]	Constructor	Function	21
+APPLY [function, arg1, ..., list]  Evaluator	Function	201
+ASCII [atom]			Character	Function	94
+ASH [n, m]			Numerical	Function	150
+ASIN [n]			Numerical	Function	137
+ASSOC [key, alist, test]	Searcher	Function	16
+ASSOC-IF [test, alist]		Searcher	Function	16
+ATAN [n]			Numerical	Function	137
+ATOM [object]			Recognizer	Function	56
+*AUTO-NEWLINE*: T		Screen		Control var.	265
+
+BACKGROUND-COLOR [n]		Screen		Function	263
+BINARY-LOAD [filename, offset]	Hardware	Function	255
+*BLINK*: NIL			Screen		Control var.	265
+BREAK [object, message]		User interface	Function	243
+BUTLAST [list, n]		Constructor	Function	26
+
+CAAAAR [object]			Selector	Function	5
+CAAADR [object]			Selector	Function	5
+CAAAR [object]			Selector	Function	5
+CAADAR [object]			Selector	Function	5
+CAADDR [object]			Selector	Function	5
+CAADR [object]			Selector	Function	5
+CAAR [object]			Selector	Function	5
+CADAAR [object]			Selector	Function	5
+CADADR [object]			Selector	Function	5
+CADAR [object]			Selector	Function	5
+CADDAR [object]			Selector	Function	5
+CADDDR [object]			Selector	Function	5
+CADDR [object]			Selector	Function	5
+CADR [object]			Selector	Function	5
+CAR [object]			Selector	Function	5
+CATCH [label, form1, ...]	Control		Special form	226
+CDAAAR [object]			Selector	Function	5
+CDAADR [object]			Selector	Function	5
+CDAAR [object]			Selector	Function	5
+CDADAR [object]			Selector	Function	5
+CDADDR [object]			Selector	Function	5
+CDADR [object]			Selector	Function	5
+CDAR [object]			Selector	Function	5
+CDDAAR [object]			Selector	Function	5
+CDDADR [object]			Selector	Function	5
+CDDAR [object]			Selector	Function	5
+CDDDAR [object]			Selector	Function	5
+CDDDDR [object]			Selector	Function	5
+CDDDR [object]			Selector	Function	5
+CDDR [object]			Selector	Function	5
+CDR [object]			Selector	Function	4
+CEILING [n, m]			Numerical	Function	143
+CHAR [atom, n]			String		Function	100
+CHAR-CODE [symbol]		Character	Function	95
+CHAR-DOWNCASE [symbol]		Character	Function	96
+CHAR-EQUAL [sym1, ... symn]	Character	Function	93
+CHAR-GREATERP [sym1, ... symn]	Character	Function	93
+CHAR-LESSP [sym1, ... symn]	Character	Function	93
+CHAR-NOT-EQUAL [sym1, ... symn]	Character	Function	93
+CHAR-NOT-GREATERP [sym1, ... ]	Character	Function	93
+CHAR-NOT-LESSP [sym1, ... symn]	Character	Function	93
+CHAR-UPCASE [symbol]		Character	Function	96
+CHAR= [symbol1, ... symboln]	Character	Function	92
+CHAR< [symbol1, ... symboln]	Character	Function	92
+CHAR> [symbol1, ... symboln]	Character	Function	92
+CHAR<= [symbol1, ... symboln]	Character	Function	92
+CHAR>= [symbol1, ... symboln]	Character	Function	92
+CHAR/= [symbol1, ... symboln]	Character	Function	92
+CLEAR-INPUT []			Input		Function	160
+CLEAR-SCREEN []			Screen		Function	259
+CODE-CHAR [n]			Character	Function	95
+COLUMN []			Screen		Function	259
+COMMENT [comments]		Control		Special form	225
+COND [cond1, ... condn]		Control		Special form	221
+CONS [obj1, obj2]		Constructor	Function	18
+CONSP [object]			Recognizer	Function	58
+CONSTANTP [object]		Evaluator	Function	197
+COPY-ALIST [alist]		Constructor	Function	22
+COPY-CHAR-TYPE [chr1, chr2, flg]Input		Function	167
+COPY-LIST [list]		Constructor	Function	22
+COPY-TREE [object]		Constructor	Function	22
+COS [n]				Numerical	Function	136
+COUNT [object, list, test]	Searcher	Function	11
+COUNT-IF [test, list]		Searcher	Function	11
+CSMEMORY [offset, value, flag]	Hardware	Function	249
+CURSOR-LINES [start, endline]	Screen		Function	264
+
+DECF [place, n]			Numerical	Macro		128
+DECQ [symbol, n]		Numerical	Special form	127
+DEFMACRO [sym, arglist, form1, ...]  Definition	Special form	88
+DEFUN [sym, arglist, form1, ...]  Definition	Special form	87
+DELETE [item, list, test]	Modifier	Function	44
+DELETE-DUPLICATES [list, test]	Modifier	Function	45
+DELETE-IF [test, list]		Modifier	Function	44
+DELETE-LINES [n]		Screen		Function	261
+DENOMINATOR [n]			Numerical	Function	141
+DIGIT-CHAR-P [symbol, n]	Character	Function	91
+DISPLAY-PAGE [n]		Screen		Function	265
+DIVIDE [n, m]			Numerical	Function	147
+DO [letlist, form1, ... formn]	Control		Macro		223
+DO* [letlist, form1, ... formn]	Control		Macro		223
+DOLIST [(var, list, result) form1, ...]  Control Macro		224
+DOTIMES [(var, count, result) form1, ...]  Control Macro	224
+DRIVER []			User interface	Function	241
+DSMEMORY [offset, value, flag]	Hardware	Function	249
+
+ECHO: NIL			I/O		Control var.	173, 190
+EIGHTH [list]			Selector	Function	7
+ENDP [object]			Recognizer	Function	59
+EOF				I/O		Keyword		159, 180
+EQ [obj1, obj2]			Comparator	Function	60
+EQL [obj1, obj2]		Comparator	Function	61
+EQUAL [obj1, obj2, test]	Comparator	Function	62
+EVAL [object]			Evaluator	Function	199
+EVAL-FUNCTION-P [symbol]	Evaluator	Function	196
+EVENP [object]			Numerical	Function	114
+EVERY [test, list1, ..., listn]	Evaluator	Function	212
+EXECUTE [program, command-line]	Control		Function	231
+EXP [n]				Numerical	Function	132
+EXPT [n, m]			Numerical	Function	133
+
+FBOUNDP [symbol]		Evaluator	Function	196
+FIFTH [list]			Selector	Function	7
+FILL [list, object]		Modifier	Function	40
+FIND [object, list, test]	Searcher	Function	14
+FIND-IF [test, list]		Searcher	Function	14
+FINDSTRING [atom1, atom2, n]	String		Function	106
+FIRST [list]			Selector	Function	7
+FIRSTN [n, list]		Constructor	Function	23
+FLAG [symbol, attribute]	Flag		Function	79
+FLAGP [symbol, attribute]	Flag		Function	79
+FLOOR [n, m]			Numerical	Function	142
+FMAKUNBOUND [symbol]		Definition	Function	85
+FOREGROUND-COLOR [n]		Screen		Function	263
+FOURTH [list]			Selector	Function	7
+*FREE-LIST*: '*FREE-LIST*	Memory		Variable	235
+FRESH-LINE []			Output		Function	185
+FUNCALL [function, arg1, ... arg2]  Evaluator	Function	203
+FUNCTIONP [object]		Evaluator	Function	197
+
+GCD [n1, n2, ..., nm]		Numerical	Function	129
+GET [symbol, key]		Property	Function	77
+GET-BREAK-CHARS []		Input		Function	172
+GET-MACRO-CHAR [char, flag]	Input		Function	167
+GETD [symbol, flag]		Definition	Function	82
+GETSET [parameter]		Miscellaneous	Function	268
+
+*HIGH-INTENSITY*: NIL		Screen		Control var.	265
+
+IDENTITY [object]		Control		Function	219
+IF [testform, thenform, elseform]  Control	Special form	220
+*IGNORE-CASE*: NIL		Input		Control var.	173
+INCF [place, n]			Numerical	Macro		128
+INCQ [symbol, n]		Numerical	Special form	127
+INPUTFILE [filename]		Input		Function	158
+INSERT-LINES [n]		Screen		Function	261
+INTEGER-LENGTH [n]		Numerical	Function	151
+INTEGERP [object]		Recognizer	Function	55
+INTERRUPT [n]			Hardware	Function	254
+INTERSECTION [list1, list2, test]  Constructor	Function	34
+ISQRT [n]			Numerical	Function	135
+
+LAMBDA				Definition	Keyword		82
+LAST [list]			Selector	Function	8
+LCM [n1, ..., nm]		Numerical	Function	131
+LCONC [dotted-pair, list]	Modifier	Function	50
+LDIFF [list, tail]		Constructor	Function	25
+LENGTH [object]			Selector	Function	10
+LET [letlist, form1, ... formn]	Control		Macro		222
+LET* [letlist, form1, ... formn]Control		Macro		222
+LINELENGTH [n]			Output		Function	189
+LINELENGTH: 'LINELENGTH		Output		Control var.	190
+LIST [obj1, ..., objn]		Constructor	Function	19
+LIST* [obj1, ..., objn]		Constructor	Function	19
+LIST-LENGTH [object]		Selector	Function	10
+LISTEN []			Input		Function	161
+LISTP [object]			Recognizer	Function	58
+LN [n]				Numerical	Function	134
+LOAD [filename]			Environment	Function	239
+LOCATION [object]		Hardware	Function	252
+LOG [n, base]			Numerical	Function	134
+LOGAND [n1, ..., nm]		Numerical	Function	149
+LOGIOR [n1, ..., nm]		Numerical	Function	149
+LOGNOT [n]			Numerical	Function	148
+LOGXOR [n1, ..., nm]		Numerical	Function	149
+LOOP [form1, ..., formn]	Control		Special form	217
+LOWER-CASE-P [symbol]		Character	Function	89
+
+MACRO				Definition	Keyword		82
+MACRO-FUNCTION [symbol]		Evaluator	Function	205
+MACRO-FUNCTION-P [symbol]	Evaluator	Function	196
+MACROEXPAND [form]		Evaluator	Function	206
+MACROEXPAND-1 [form]		Evaluator	Function	206
+MAKE-LIST [n, object, list]	Constructor	Function	20
+MAKE-RANDOM-STATE [state]	Numerical	Function	153
+MAKE-WINDOW [row, col, rows, cols]  Screen	Function	262
+MAPC [function, list1, ...]	Evaluator	Function	208
+MAPCAN [function, list1, ...]	Evaluator	Function	210
+MAPCAR [function, list1, ...]	Evaluator	Function	209
+MAPCON [function, list1, ...]	Evaluator	Function	210
+MAPL [function, list1, ...]	Evaluator	Function	208
+MAPLIST [function, list1, ...]	Evaluator	Function	209
+MAX [n1, ..., nm]		Numerical	Function	121
+MEMBER [object, list, test]	Searcher	Function	13
+MEMBER-IF [test, list]		Searcher	Function	13
+MEMORY [address, value, flag]	Hardware	Function	247
+MERGE [list1, list2, test]	Modifier	Function	52
+MIN [n1, ..., nm]		Numerical	Function	121
+MINUSP [object]			Numerical	Function	113
+MISMATCH [list1, list2, test]	Searcher	Function	12
+MOD [n, m]			Numerical	Function	146
+MOVD [symbol1, symbol2]		Definition	Function	84
+
+NBUTLAST [list, n]		Modifier	Function	42
+NCONC [list1, ..., listn]	Modifier	Function	41
+NEQ [obj1, obj2]		Comparator	Function	60
+NEQL [obj1, obj2]		Comparator	Function	61
+NIL				Evaluator	Constant	197
+NINTH [list]			Selector	Function	7
+NLAMBDA				Definition	Keyword		82
+NO-EVAL-FUNCTION-P [symbol]	Evaluator	Function	196
+NOT [object]			Logical		Function	65
+NOTANY [test, list1, ...]	Evaluator	Function	211
+NOTEVERY [test, list1, ...]	Evaluator	Function	212
+NRECONC [list, object]		Modifier	Function	43
+NREVERSE [list, object]		Modifier	Function	43
+NSUBLIS [alist, object, test]	Modifier	Function	48
+NSUBST [new, old, object, test]	Modifier	Function	47
+NSUBST-IF [new, test, object]	Modifier	Function	47
+NSUBSTITUTE [new, old, list, test]  Modifier	Function	46
+NSUBSTITUTE-IF [new, test, list]  Modifier	Function	46
+NTH [n, list]			Selector	Function	9
+NTHCDR [n, list]		Selector	Function	9
+NULL [object]			Recognizer	Function	57
+NUMBERP [object]		Recognizer	Function	55
+NUMERATOR [n]			Numerical	Function	141
+NUMERIC-CHAR-P [symbol]		Character	Function	90
+
+OBLIST []			Constructor	Function	37
+ODDP [object]			Numerical	Function	114
+OPENFILES []			Input		Function	158
+OR [form1, ..., formn]		Logical		Special form	67
+ORDERP [object1, object2]	Comparator	Function	64
+OUTPUTFILE [filename]		Output		Function	179
+
+PACK [list]			String		Function	98
+PACK* [atom1, ..., atomn]	String		Function	98
+PAIRLIS [keys, objects, alist]	Constructor	Function	36
+PEEK-CHAR [flag]		Input		Function	164
+PI []				Numerical	Function	138
+PLUSP [object]			Numerical	Function	113
+POP [symbol]			Assignment	Special form	73
+PORTIO [port, value, flag]	Hardware	Function	251
+POSITION [object, list, test]	Searcher	Function	15
+POSITION-IF [test, list]	Searcher	Function	15
+PRECISION [n]			Numerical	Function	109
+PRIN1 [object]			Output		Function	183
+PRINC [object]			Output		Function	184
+PRINT [object]			Output		Function	184
+*PRINT-BASE*: 10		Output		Control var.	191
+*PRINT-DOWNCASE*: NIL		Output		Control var.	190
+*PRINT-ESCAPE*: T		Output		Control var.	191
+PRINT-LENGTH [atom]		String		Function	107
+*PRINT-POINT*: 7		Output		Control var.	192
+*PRINTER-ECHO*: NIL		Output		Control var.	193
+PROG1 [form1, ... formn]	Control		Special form	218
+PROG2 [form1, ... formn]	Control		Macro		218
+PROGN [form1, ... formn]	Control		Special form	216
+PSETQ [symbol1, form1, ...]	Assignment	Special form	71
+PUSH [form, symbol]		Assignment	Special form	74
+PUSHNEW [form, symbol, test]	Assignment	Macro		74
+PUT [symbol, key, object]	Property	Function	76
+PUTD [symbol, definition]	Definition	Function	83
+PUTD: 'PUTD			Definition	Control var.	86
+
+QUOTE [object]			Control		Special form	215
+
+RANDOM [n, state]		Numerical	Function	152
+*RANDOM-STATE*			Numerical	Control var.	153
+RANDOM-STATE-P [object]		Numerical	Function	154
+RASSOC [key, alist, test]	Searcher	Function	17
+RASSOC-IF [test, alist]		Searcher	Function	17
+RATIONALP [object]		Recognizer	Function	55
+RATOM []			Input		Function	171
+RDS [filename]			Input		Function	156
+READ []				Input		Function	166
+*READ-BASE*: 10			Input		Control var.	173
+READ-BYTE []			Input		Function	165
+READ-CHAR [peek-flag]		Input		Function	162
+READ-CHAR: 'READ-CHAR		Input		Control var.	173
+READ-LINE []			Input		Function	165
+*READ-UPCASE*: T		Input		Control var.	174
+READPTR [n]			Input		Function	159
+RECLAIM []			Memory		Function	232
+REDUCE [function, list, init]	Evaluator	Function	213
+REGISTER [n, m]			Hardware	Function	253
+REM [n, m]			Numerical	Function	146
+REMD [symbol]			Definition	Function	85
+REMFLAG [symbol, attribute]	Flag		Function	80
+REMOVE [item, list, test]	Constructor	Function	28
+REMOVE-DUPLICATES [list, test]	Constructor	Function	29
+REMOVE-IF [test, list]		Constructor	Function	28
+REMPROP [symbol, key]		Property	Function	78
+REPLACE [list1, list2]		Modifier	Function	40
+REST [list]			Selector	Function	7
+RESTART []			Control		Function	230
+RETURN [object]			Control		Function	229
+REVAPPEND [list, object]	Constructor	Function	27
+REVERSE [list, object]		Constructor	Function	27
+ROUND [n, m]			Numerical	Function	145
+ROW []				Screen		Function	259
+RPLACA [obj1, obj2]		Modifier	Function	38
+RPLACD [obj1, obj2]		Modifier	Function	39
+
+SAVE [filename]			Environment	Function	237
+SECOND [list]			Selector	Function	7
+SET [symbol, object]		Assignment	Function	69
+SET-BREAK-CHARS [list, flag]	Input		Function	172
+SET-CURSOR [row, column]	Screen		Function	259
+SET-DIFFERENCE [list1, list2, test]  Constructor  Function	35
+SET-MACRO-CHAR [char, defn, flg]  Input		Function	167
+SETF [place1, form1, ... ]	Assignment	Macro		72
+SETQ [symbol1, form1, ...]	Assignment	Special form	70
+SEVENTH [list]			Selector	Function	7
+SHIFT [n, m]			Numerical	Function	150
+SIGNUM [n]			Numerical	Function	140
+SIN [n]				Numerical	Function	136
+SIXTH [list]			Selector	Function	7
+SNAPSHOT [address, atom]	Hardware	Function	256
+SOME [test, list1, ... listn]	Evaluator	Function	211
+SORT [list, test]		Modifier	Function	53
+SPACES [n]			Output		Function	186
+SPECIAL				Definition	Keyword		82
+SPECIAL-FORM-P [symbol]		Evaluator	Function	196
+SPLIT [list]			Modifier	Function	51
+SQRT [n]			Numerical	Function	135
+STABLE-SORT [list, test]	Modifier	Function	53
+STACK-LIST []			Constructor	Function	37
+STRING-CAPITALIZE [atom]	String		Function	105
+STRING-DOWNCASE [atom]		String		Function	105
+STRING-EQUAL [atom1, atom2]	String		Macro		101
+STRING-GREATERP [atom1, atom2]	String		Macro		103
+STRING-LEFT-TRIM [chars, atom]	String		Function	104
+STRING-LESSP [atom1, atom2]	String		Macro		103
+STRING-NOT-EQUAL [atm1, atm2]	String		Macro		103
+STRING-NOT-GREATERP [atm1, atm2]  String	Macro		103
+STRING-NOT-LESSP [atm1, atm2]	String		Macro		103
+STRING-RIGHT-TRIM [chars, atom]	String		Function	104
+STRING-TRIM [chars, atom]	String		Function	104
+STRING-UPCASE [atom]		String		Function	105
+STRING=  [atom1, atom2, flag]	String		Function	101
+STRING<  [atom1, atom2, flag]	String		Function	102
+STRING>  [atom1, atom2, flag]	String		Function	102
+STRING<=  [atom1, atom2, flag]	String		Function	102
+STRING>=  [atom1, atom2, flag]	String		Function	102
+STRING/=  [atom1, atom2, flag]	String		Function	102
+STRINGP [object]		Recognizer	Function	54
+SUB1 [n]			Numerical	Function	126
+SUBLIS [alist, object, test]	Constructor	Function	32
+SUBLIST [list, n, m]		Constructor	Function	24
+SUBSETP [list1, list2, test]	Comparator	Function	63
+SUBST [new, old, object, test]	Constructor	Function	31
+SUBST-IF [new, test, object]	Constructor	Function	31
+SUBSTITUTE [new, old, list, test]  Constructor	Function	30
+SUBSTITUTE-IF [new, test, list]	Constructor	Function	30
+SUBSTRING [atom, n, m]		String		Function	99
+SYMBOL-FUNCTION [symbol]	Evaluator	Function	198
+SYMBOL-PLIST [symbol]		Evaluator	Function	198
+SYMBOL-VALUE [symbol]		Evaluator	Function	198
+SYMBOLP [object]		Recognizer	Function	54
+SYSTEM [n]			Control		Function	230
+
+TAILP [list1, list2]		Comparator	Function	63
+TAN [n]				Numerical	Function	136
+TCONC [dotted-pair, object]	Modifier	Function	49
+TENTH [list]			Selector	Function	7
+TERPRI [n]			Output		Function	185
+THIRD [list]			Selector	Function	7
+THROW [label, object]		Control		Function	228
+TIME [flag]			Miscellaneous	Function	267
+TONE [frequency, duration]	Miscellaneous	Function	266
+TREE-EQUAL [object1, object2, test]  Comparator	Function	62
+TRUNCATE [n, m]			Numerical	Function	144
+
+UNDEFINED [symbol, form1, ...]	Evaluator	Function	204
+UNDERFLOW [n]			Numerical	Function	111
+UNION [list1, list2, test]	Constructor	Function	34
+UNLESS [testform, form1, ... formn]  Control	Macro		220
+UNPACK [atom]			String		Function	97
+UNREAD-CHAR []			Input		Function	163
+UNWIND-PROTECT [form1, form2, ...]  Control	Special form	227
+UPPER-CASE-P [symbol]		Character	Function	89
+
+WHEN [testform, form1, ... formn]  Control	Macro		220
+WRITE-BYTE [n]			Output		Function	188
+WRITE-LINE [symbol]		Output		Function	187
+WRITE-STRING [symbol]		Output		Function	187
+WRITEPTR [n]			Output		Function	180
+WRS [filename, reopen-flag]	Output		Function	176
+
+Y-OR-N-P [message]		User interface	Function	246
+YES-OR-NO-P [message]		User interface	Function	246
+
+ZEROP [object]			Numerical	Function	112
++ [n1, ..., nm]			Numerical	Function	122
+- [n1, ..., nm]			Numerical	Function	123
+* [n1, ..., nm]			Numerical	Function	124
+/ [n1, ..., nm]			Numerical	Function	125
+
+= [n1, ..., nm]			Numerical	Function	115
+/= [n1, ..., nm]		Numerical	Function	116
+< [n1, ..., nm]			Numerical	Function	117
+> [n1, ..., nm]			Numerical	Function	118
+<= [n1, ..., nm]		Numerical	Function	119
+>= [n1, ..., nm]		Numerical	Function	120
+
+\  back slash			Input		Escape char.	166
+|  vertical bar			Input		Escape char.	166
+
+(  left parenthesis		Input		Macro char.	168
+)  right parenthesis		Input		Macro char.	168
+]  right square bracket		Input		Macro char.	168
+,  comma			Input		Macro char.	169
+'  single quote			Input		Macro char.	169
+"  double quote			Input		Macro char.	170
+;  semicolon			Input		Macro char.	169
+
+++				User interface	Variable	241
++++				User interface	Variable	241
+**				User interface	Variable	241
+***				User interface	Variable	241
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/INTERLIS.LSP b/Microsoft muLISP-86 v51/INTERLIS.LSP
new file mode 100644
index 0000000..43598f6
--- /dev/null
+++ b/Microsoft muLISP-86 v51/INTERLIS.LSP	
@@ -0,0 +1,714 @@
+;File:  INTERLIS.LSP		12/27/85	Soft Warehouse, Inc.
+
+
+;			Interlisp Compatiblity File
+
+;References in this file are to the 1978 edition of the Interlisp Reference
+;Manual, by Warren Teitelman, published by the Xerox Palo Alto Research
+;Center and Bolt, Beranek & Newman.  Each function definition is preceded
+;by a brief description of its affect and value.  See the Interlisp
+;Reference Manual for a more complete description of the function.
+
+
+
+;	Section 5:  Primitive Functions and Predicates
+
+;RPLNODE [object1, object2, object3]  replaces the car of <object1>
+;with <object2> and the cdr of <object1> with <object3>.
+
+(DEFUN RPLNODE (OBJ1 OBJ2 OBJ3)
+  (RPLACD (RPLACA OBJ1 OBJ2) OBJ3) )
+
+
+;RPLNODE2 [object1, object2]  replaces the car of <object1> with the
+;car of <object2> and the cdr of <object1> with the cdr of <object2>.
+
+(DEFUN RPLNODE2 (OBJ1 OBJ2)
+  (RPLACD (RPLACA OBJ1 (CAR OBJ2)) (CDR OBJ2)) )
+
+
+;KWOTE [object]  returns an expression that when evaluated is <object>.
+
+(DEFUN KWOTE (OBJ)
+  ((OR (NULL OBJ) (NUMBERP OBJ)) OBJ)
+  (LIST 'QUOTE OBJ) )
+
+
+;SELECTQ [object, clause1, clause2, ..., default]  based on <object>,
+;selects a clause list to be sequentially evaluated.
+
+(DEFUN SELECTQ (NLAMBDA LST$
+  (SELECTQ-AUX (EVAL (CAR LST$)) (CDR LST$)) ))
+
+(DEFUN SELECTQ-AUX (OBJ LST)
+  ((NULL LST) NIL)
+  (LOOP
+    ((NULL (CDR LST))
+      (EVAL (CAR LST)) )
+    ((OR (EQ OBJ (CAAR LST))
+	(AND (NOT (ATOM (CAAR LST))) (MEMBER OBJ (CAAR LST))) )
+      (SETQ LST (CDAR LST))
+      (LOOP
+	((NULL (CDR LST))
+	  (EVAL (CAR LST)) )
+	(EVAL (POP LST)) ) )
+    (POP LST) ) )
+
+
+;SETQQ [name, expression]  a no-eval function that sets <name> to
+;<expression>.
+
+(DEFUN SETQQ (NLAMBDA (NAM$ EXP$)
+  (SET NAM$ EXP$)
+  EXP$ ))
+
+
+(MOVD 'NAME 'LITATOM)			;Literal atom predicate
+
+(MOVD 'ATOM 'NLISTP)			;No list predicate
+
+(DEFUN NILL NIL				;Returns NIL
+  NIL )
+
+(MOVD 'EQL 'EQP)
+
+
+;EQLENGTH [list, n]  is equivalent to EQ [LENGTH[list], n].
+
+(DEFUN EQLENGTH (LST NUM)
+  (LOOP
+    ((ATOM LST)
+      (ZEROP NUM) )
+    ((ZEROP NUM) NIL)
+    (POP LST)
+    (DECQ NUM) ) )
+
+
+;EQUALN [object1, object2, n]  is equivalent to EQUAL except that the
+;comparison is limited to a depth of <n> levels of recursion.  If that
+;depth is exceeded, '? is returned instead.
+
+(DEFUN EQUALN (OBJ1 OBJ2 NUM TEMP)
+  (LOOP
+    ((ATOM OBJ1)
+      (EQ OBJ1 OBJ2) )
+    ((ATOM OBJ2) NIL)
+    ((NOT (PLUSP NUM))
+      '? )
+    (DECQ NUM)
+    (SETQ TEMP (EQUALN (POP OBJ1) (POP OBJ2) NUM))
+    ((OR (NULL TEMP) (EQ TEMP ?)) TEMP) ) )
+
+
+(MOVD 'MEMBER 'MEMB)
+
+
+;EQMEMB [atom, list]  returns T if EQ [atom, list] or MEMB [atom, list].
+;Otherwise, it returns NIL.
+
+(DEFUN EQMEMB (ATM LST)
+  ((EQ ATM LST))
+  (MEMB ATM LST) )
+
+
+;PUTASSOC [key, object, a-list]  replaces the value associated with
+;<key> on <a-list> with <object>.
+
+(DEFUN PUTASSOC (KEY OBJ ALST
+    TEMP )
+  (SETQ TEMP (ASSOC KEY ALST))
+  ((NULL TEMP)
+    (NCONC ALST (LIST (CONS KEY OBJ)))
+    OBJ )
+  (RPLACD TEMP OBJ)
+  OBJ )
+
+
+;	Section 6:  List Manipulation and Concatenation
+
+;NCONC1 [list, object]  adds <object> to the end of <list> by modifying
+;the last cons of <list>.
+
+(DEFUN NCONC1 (LST OBJ)
+  (NCONC LST (CONS OBJ)) )
+
+
+;DOCOLLECT [object, list]  efficiently adds <object> to the end of
+;<list> which is maintained as a pointer to a circular list.
+
+(DEFUN DOCOLLECT (OBJ LST)
+  ((ATOM LST)
+    (CONS OBJ) )
+  ((ATOM (CDR LST))
+    ((NULL (CAR LST))
+      (RPLACA LST OBJ) )
+    (RPLACD LST (CONS OBJ))
+    (RPLACD (CDR LST) (CDR LST))
+    LST )
+  (RPLACD (CDR LST) (CONS OBJ (CDDR LST)))
+  (RPLACD LST (CDDR LST)) )
+
+
+;ENDCOLLECT [list, tail]  replaces the tail of <list> with <tail> making
+;<list> no longer circular and returns the resulting list.
+
+(DEFUN ENDCOLLECT (LST TAIL)
+  ((ATOM LST) TAIL)
+  ((ATOM (CDR LST))
+    ((NULL (CAR LST))
+      ((ATOM TAIL) TAIL)
+      (RPLNODE2 LST TAIL) )
+    (RPLACD LST TAIL) )
+  (RPLACD LST (PROG1 (CDDR LST) (RPLACD (CDR LST) TAIL))) )
+
+
+;ATTACH [object, list]  adds <object> to the front of <list> by
+;modifying the first cons of <list>.
+
+(DEFUN ATTACH (OBJ LST)
+  ((NULL LST)
+    (CONS OBJ) )
+  ((ATOM LST) NIL)
+  (RPLACA (RPLACD LST (CONS (CAR LST) (CDR LST))) OBJ) )
+
+
+;DREMOVE [atom, list]  removes <atom> from <list> by modifying <list>.
+
+(DEFUN DREMOVE (ATM LST
+    TEMP )
+  ((ATOM LST) NIL)
+  ((EQ ATM (CAR LST))
+    ((ATOM (CDR LST)) NIL)
+    (RPLACA LST (CADR LST))
+    (RPLACD LST (CDDR LST))
+    (DREMOVE ATM LST) )
+  (SETQ TEMP LST)
+  (LOOP
+    ((ATOM (CDR TEMP)) LST)
+    ( ((EQ ATM (CADR TEMP))
+	(RPLACD TEMP (CDDR TEMP)) )
+      (POP TEMP) ) ) )
+
+
+;MKLIST [object]  returns (LIST object) if <object> is a nonNIL atom;
+;otherwise, it returns <object>.
+
+(DEFUN MKLIST (OBJ)
+  ((NULL OBJ) OBJ)
+  ((ATOM OBJ)
+    (CONS OBJ) )
+  OBJ )
+
+
+;COPY [object]  copies <object> down to the atomic level.
+
+(MOVD 'COPY-TREE 'COPY)
+
+
+;DREVERSE [list]  reverses <list> without consing by modifying <list>.
+
+(MOVD NREVERSE DREVERSE)
+
+
+;DSUBST [new, old, object]  substitutes <new> for all sub-expressions
+;EQUAL to <old> in <object> without consing.
+
+(DEFUN DSUBST (NEW OLD OBJ)
+  ((EQUAL OLD OBJ) NEW)
+  ((ATOM OBJ) OBJ)
+  (RPLACD (RPLACA OBJ (DSUBST NEW OLD (CAR OBJ)))
+	(DSUBST NEW OLD (CDR OBJ))) )
+
+
+;SUBLIS [a-list, object, flag]  substitutes in <object> for each key in
+;<a-list> the associated value.  If <flag> is NIL, a new structure is
+;created only if necessary.  If <flag> is nonNIL, new structure is always
+;created.
+
+(DEFUN SUBLIS (ALST OBJ FLG
+    TEMP1 TEMP2 )
+  ((ATOM OBJ)
+    (SETQ TEMP1 (ASSOC OBJ ALST))
+    ((NULL TEMP1) OBJ)
+    (CDR TEMP1) )
+  (SETQ TEMP1 (SUBLIS ALST (CAR OBJ) FLG)
+	TEMP2 (SUBLIS ALST (CDR OBJ) FLG))
+  ((AND (NOT FLG) (EQ (CAR OBJ) TEMP1) (EQ (CDR OBJ) TEMP2)) OBJ)
+  (CONS TEMP1 TEMP2) )
+
+
+;NLEFT [list, n, tail]  returns <n> more elements from the end of <list>
+;than <tail>.  <tail> should be NIL or a tail of <list>.
+
+(DEFUN NLEFT (LST NUM TAIL)
+  ((OR (NULL LST) (EQ LST TAIL))
+    ((OR (NOT (NUMBERP NUM)) (ZEROP NUM)) LST)
+    1 )
+  (SETQ TAIL (NLEFT (CDR LST) NUM TAIL))
+  ((NUMBERP TAIL)
+    ((EQ TAIL NUM) LST)
+    (ADD1 TAIL) )
+  TAIL )
+
+
+;LASTN [list, n]  returns CONS[list1,list2] where <list2> is the last
+;<n> elements of <list> and <list1> is the remaining elements of <list>.
+
+(DEFUN LASTN (LST NUM
+    TAIL )
+  ((NULL (SETQ TAIL (NLEFT LST NUM))) NIL)
+  (CONS (LDIFF LST TAIL) TAIL) )
+
+
+;EQLENGTH [list, n]  was defined earlier.
+
+
+;COUNTDOWN [object, n]  returns the larger of 0 or <n> minus the number
+;of nodes in <object>.
+
+(DEFUN COUNTDOWN (OBJ NUM)
+  ((ZEROP NUM) NUM)
+  ((PLUSP NUM)
+    (LOOP
+      ((ATOM OBJ) NUM)
+      (SETQ NUM (COUNTDOWN (POP OBJ) (SUB1 NUM)))
+      ((ZEROP NUM) NUM) ) ) )
+
+
+;LDIFF [list1, tail, list2]  returns a list of the elements of <list1>
+;up to <tail> nconced onto <list2>.
+
+(DEFUN LDIFF (LST1 TAIL LST2)
+  ((ATOM TAIL)
+    (NCONC LST2 LST1) )
+  (NCONC LST2 (LDIFF-AUX LST1)) )
+
+(DEFUN LDIFF-AUX (LST)
+  ((OR (ATOM LST) (EQ LST TAIL)) NIL)
+  (CONS (CAR LST) (LDIFF-AUX (CDR LST))) )
+
+
+;LDIFFERENCE [list1, list2]  returns a list of the elements in <list1>
+;that are not a MEMBER of <list2>.
+
+(MOVD 'SET-DIFFERENCE 'LDIFFERENCE)
+
+
+;ALPHORDER [atom1, atom2]  a predicate for alphabetizing atoms.  Numbers
+;come before names and are sorted numerically.
+
+(MOVD 'STRING< 'ALPHORDER)
+
+
+;	Section 7:  Property Lists and Hash Links
+
+;In muLISP, property lists are association lists of the form:
+;	((KEY.VALUE) (KEY.VALUE) ... (KEY.VALUE)).
+
+;In Interlisp, property lists are lists of the form:
+;	(KEY VALUE KEY VALUE ... KEY VALUE).
+
+
+;GETPROPLIST [name]  returns <name>'s p-list (property list).
+
+(DEFUN GETPROPLIST (NAM)
+  ((NAME NAM)
+    (CDR NAM) ) )
+
+
+;SETPROPLIST [name, list]  replaces the p-list of <name> with <list>
+;and returns <list>.
+
+(DEFUN SETPROPLIST (NAM LST)
+  ((AND NAM (NAME NAM))
+    (RPLACD NAM LST)
+    LST ) )
+
+
+;GETPROP [name, key]  returns the property value on <name>'s p-list under
+;the indicator <key>.  NIL is returned if no such property exists.
+;GETPROP is equivalent to the muLISP function GET.
+
+(MOVD 'GET 'GETPROP)
+
+
+;PUTPROP [name, key, object]  puts on <name>'s p-list under the indicator
+;<key> the property value <object>.  PUTPROP is equivalent to the muLISP
+;function PUT.
+
+(MOVD 'PUT 'PUTPROP)
+
+
+;PUTPROPS [name, key1, object1, ..., keyn, objectn]  an NLAMBDA, no-spread
+;function that puts properties on <name>'s p-list.
+
+(DEFUN PUTPROPS (NLAMBDA LST$
+  (PUTPROPS-AUX (CAR LST$) (CDR LST$)) ))
+
+(DEFUN PUTPROPS-AUX (NAM LST)
+  (LOOP
+    ((ATOM LST) NAM)
+    (PUT NAM (POP LST) (POP LST)) ) )
+
+
+;PUTQQ [name, key, object]  a no-eval function that puts on <name>'s
+;p-list under <key> the property value <object>.  If a PUTQQ command is
+;issued from the muSTAR editor, the property is flagged for saving,
+;making PUTQQ roughly equivalent to the Interlisp SAVEPUT function.
+
+
+;ADDPROP [name, key, object, flag]  nconcs <object> to the <key>
+;property on <name>'s p-list if <flag> is NIL.  If <flag> is nonNIL,
+;<object> is consed onto the front of the property.
+
+(DEFUN ADDPROP (NAM KEY OBJ FLG
+    TEMP )
+  (SETQ TEMP (ASSOC KEY (CDR NAM)))
+  ((NULL TEMP)
+    (PUTPROP NAM KEY (LIST OBJ)) )
+  ((NULL FLG)
+    (CDR (NCONC TEMP (LIST OBJ))) )
+  (CDR (RPLACD TEMP (CONS OBJ (CDR TEMP)))) )
+
+
+;REMPROP [name, key]  removes the property <key> from <name>'s p-list.
+;REMPROP is a primitively defined muLISP function.
+
+
+;REMPROPLIST [name, list]  removes from <name>'s p-list the properties
+;whose keys are members of <list>.
+
+(DEFUN REMPROPLIST (NAM LST)
+  (LOOP
+    ((ATOM LST) NIL)
+    (REMPROP NAM (POP LST)) ) )
+
+
+;CHANGEPROP [name, key1, key2]  replaces the key for the <key1> property
+;on <name>'s p-list with <key2>.
+
+(DEFUN CHANGEPROP (NAM KEY1 KEY2)
+  ((SETQ KEY1 (ASSOC KEY1 (CDR NAM)))
+    (RPLACA KEY1 KEY2)
+    NAM ) )
+
+
+;PROPNAMES [name]  returns a list of the keys on <name>'s p-list.
+
+(DEFUN PROPNAMES (NAM
+    LST )
+  (LOOP
+    (SETQ NAM (CDR NAM))
+    ((NULL NAM)
+      (REVERSE LST) )
+    ( ((ATOM (CAR NAM)))
+      (PUSH (CAAR NAM) LST) ) ) )
+
+
+;GETLIS [name, list]  returns <name>'s p-list beginning with the first
+;key that is a member of <list>.
+
+(DEFUN GETLIS (NAM LST)
+  ((NULL NAM) NIL)
+  ( ((NAME NAM)
+      (SETQ NAM (CDR NAM)) ) )
+  (LOOP
+    ((NULL NAM) NIL)
+    ((AND (NOT (ATOM (CAR NAM))) (MEMBER (CAAR NAM) LST))
+      NAM )
+    (POP NAM) ) )
+
+
+;DEFLIST [list, key]  for each element of <list>, puts on the p-list of
+;the car of the element under the indicator <key> the cadr of the element.
+
+(DEFUN DEFLIST (LST KEY)
+  (LOOP
+    ((NULL LST) NIL)
+    (PUTPROP (CAAR LST) KEY (CADAR LST))
+    (POP LST) ) )
+
+
+
+;	Section 8:  Function Definition and Evaluation
+
+;DEFINE [definition-list]  defines the functions on <definition-list>
+;where each element of <definition-list> is a list of the form:
+;	(name (LAMBDA (arg-list) body)),
+;or of the form:
+;	(name (arg-list) body).
+
+(DEFUN DEFINE (LST
+    OBJ )
+  (LOOP
+    ((ATOM LST) NIL)
+    (SETQ OBJ (POP LST))
+    ( ((OR (ATOM OBJ) (NOT (NAME (CAR OBJ)))))
+      ((OR (EQ (CAADR OBJ) 'LAMBDA) (EQ (CAADR OBJ) 'NLAMBDA))
+	(PUTD (CAR OBJ) (CADR OBJ)) )
+      (PUTD (CAR OBJ) (CONS 'LAMBDA (CDR OBJ))) ) ) )
+
+
+;DEFINEQ [list1, list2, ..., listn]  a no-eval function that applies
+;DEFINE to each element of <list1> through <listn>.
+
+(DEFUN DEFINEQ (NLAMBDA LST$
+  (DEFINE LST$) ))
+
+
+;BOUNDP [name]  returns T if <name> currently has a value other than
+;itself or NOBIND.  Otherwise it returns NIL.
+
+(DEFUN BOUNDP (NAM)
+  (NOT (OR (EQ NAM (CAR NAM)) (EQ (CAR NAM) 'NOBIND))) )
+
+
+;APPLY* [function, arg1, arg2, ..., argn]  applies <function> to the
+;arguments <arg1> through <argn>.  The <function> argument in a call
+;to APPLY* is not evaluated.
+
+(DEFMACRO APPLY* (FUNC . ARGS)
+  (CONS* 'FUNCALL (LIST 'QUOTE FUNC) ARGS) )
+
+
+;RPT [n, expression]  evaluates <expression> <n> times.
+
+(DEFUN RPT (NUM EXP)
+  ((PLUSP NUM)
+    (LOOP
+      ((EQ NUM 1)
+	(EVAL EXP) )
+      (EVAL EXP)
+      (DECQ NUM) ) ) )
+
+
+;RPTQ [n, expression]  is equivalent to RPT except <expression> is not
+;evaluated before the function is called.
+
+(DEFUN RPTQ (NLAMBDA (NUM$ EXP$)
+  (RPT (EVAL NUM$) EXP$) ))
+
+
+
+;	Section 11:  Functions with Functional Arguments
+
+
+;Since the map functions in this section conflict with the primitive muLISP
+;map functions, their names are preceeded with an I standing for Interlisp.
+
+;IMAP [list, function1, function2]  if <function2> is NIL, it applies
+;<function1> to successive cdrs of <list> beginning with the whole list.
+;If <function2> is nonNIL, it uses <function2> instead of cdr to step
+;through <list>.
+
+(DEFUN IMAP (LST FUN1 FUN2)
+  ((NULL FUN2)
+    (LOOP
+      ((ATOM LST) NIL)
+      (FUNCALL FUN1 LST)
+      (POP LST) ) )
+  (LOOP
+    ((ATOM LST) NIL)
+    (FUNCALL FUN1 LST)
+    (SETQ LST (FUNCALL FUN2 LST)) ) )
+
+
+;IMAPC [list, function1, function2]  if <function2> is NIL, it applies
+;<function1> to successive elements of <list> beginning with the whole
+;list.  If <function2> is nonNIL, it uses <function2> instead of cdr
+;to step through <list>.
+
+(DEFUN IMAPC (LST FUN1 FUN2)
+  ((NULL FUN2)
+    (LOOP
+      ((ATOM LST) NIL)
+      (FUNCALL FUN1 (POP LST)) ) )
+  (LOOP
+    ((ATOM LST) NIL)
+    (FUNCALL FUN1 (CAR LST))
+    (SETQ LST (FUNCALL FUN2 LST)) ) )
+
+
+;IMAPLIST [list, function1, function2]  returns a list of the same values
+;computed by IMAP [list, function1, function2].
+
+(DEFUN IMAPLIST (LST FUN1 FUN2)
+  ((ATOM LST) NIL)
+  ((NULL FUN2)
+    (CONS (FUNCALL FUN1 LST) (IMAPLIST (CDR LST) FUN1)) )
+  (CONS (FUNCALL FUN1 LST) (IMAPLIST (FUNCALL FUN2 LST) FUN1 FUN2)) )
+
+
+;IMAPCAR [list, function1, function2]  returns a list of the same values
+;computed by IMAPC [list, function1, function2].
+
+(DEFUN IMAPCAR (LST FUN1 FUN2)
+  ((ATOM LST) NIL)
+  ((NULL FUN2)
+    (CONS (FUNCALL FUN1 (CAR LST)) (IMAPCAR (CDR LST) FUN1)) )
+  (CONS (FUNCALL FUN1 (CAR LST)) (IMAPCAR (FUNCALL FUN2 LST) FUN1 FUN2)) )
+
+
+;IMAPCON [list, function1, function2]  concatenates the values computed
+;by IMAP [list, function1, function2] using NCONC.
+
+(DEFUN IMAPCON (LST FUN1 FUN2
+    RSLT ANS )
+  (LOOP
+    ((ATOM LST) RSLT)
+    (SETQ RSLT (FUNCALL FUN1 LST))
+    (SETQ LST (COND
+	(FUNCALL FUN2 (FUNCALL FUN2 LST))
+	((CDR LST)) ))
+    ((NOT (ATOM RSLT))
+      (SETQ ANS RSLT)
+      (LOOP
+	((ATOM LST) ANS)
+	(SETQ RSLT (LAST RSLT))
+	(RPLACD RSLT (FUNCALL FUN1 LST))
+	(SETQ LST (COND
+	  (FUNCALL FUN2 (FUNCALL FUN2 LST))
+	  ((CDR LST)) )) ) ) ) )
+
+
+;IMAPCONC [list, function1, function2]  concatenates the values computed
+;by IMAPC [list, function1, function2] using NCONC.
+
+(DEFUN IMAPCONC (LST FUN1 FUN2
+    RSLT ANS )
+  (LOOP
+    ((ATOM LST) RSLT)
+    (SETQ RSLT (FUNCALL FUN1 (CAR LST)))
+    (SETQ LST (COND
+	(FUNCALL FUN2 (FUNCALL FUN2 LST))
+	((CDR LST)) ))
+    ((NOT (ATOM RSLT))
+      (SETQ ANS RSLT)
+      (LOOP
+	((ATOM LST) ANS)
+	(SETQ RSLT (LAST RSLT))
+	(RPLACD RSLT (FUNCALL FUN1 (CAR LST)))
+	(SETQ LST (COND
+	  (FUNCALL FUN2 (FUNCALL FUN2 LST))
+	  ((CDR LST)) )) ) ) ) )
+
+
+;SUBSET [list, function1, function2]  applies <function1> to the elements
+;of <list> and returns a list of the elements for which the results were
+;nonNIL.  If <function2> is nonNIL, it is used for stepping through <list>.
+
+(DEFUN SUBSET (LST FUN1 FUN2)
+  ((ATOM LST) NIL)
+  ((FUNCALL FUN1 (CAR LST))
+    (CONS (CAR LST) (SUBSET (COND
+	  (FUNCALL FUN2 (FUNCALL FUN2 LST))
+	  ((CDR LST)) ) FUN1 FUN2)) )
+  (SUBSET (COND
+      (FUNCALL FUN2 (FUNCALL FUN2 LST))
+      ((CDR LST)) ) FUN1 FUN2) )
+
+
+;IMAP2C [list1, list2, function1, function2]  if <function2> is NIL, it
+;applies <function1> to successive elements of <list1> and <list2>.  If
+;<function2> is nonNIL, it uses <function2> instead of cdr to step
+;through <list>.
+
+(DEFUN IMAP2C (LST1 LST2 FUN1 FUN2)
+  ((NULL FUN2)
+    (LOOP
+      ((OR (ATOM LST1) (ATOM LST2)) NIL)
+      (FUNCALL FUN1 (POP LST1) (POP LST2)) ) )
+  (LOOP
+    ((OR (ATOM LST1) (ATOM LST2)) NIL)
+    (FUNCALL FUN1 (CAR LST1) (CAR LST2))
+    (SETQ LST1 (FUNCALL FUN2 LST1)
+	  LST2 (FUNCALL FUN2 LST2)) ) )
+
+
+;IMAP2CAR [list1, list2, function1, function2]  returns a list of the
+;same values computed by IMAP2C [list1, list2, function1, function2].
+
+(DEFUN IMAP2CAR (LST1 LST2 FUN1 FUN2)
+  ((OR (ATOM LST1) (ATOM LST2)) NIL)
+  ((NULL FUN2)
+    (CONS (FUNCALL FUN1 (CAR LST1) (CAR LST2))
+	  (IMAP2CAR (CDR LST1) (CDR LST2) FUN1)) )
+  (CONS (FUNCALL FUN1 (CAR LST1) (CAR LST2))
+	(IMAP2CAR (FUNCALL FUN2 LST1) (FUNCALL FUN2 LST2) FUN1 FUN2)) )
+
+
+
+;	Section 13:  Numbers and Arithmetic Functions
+
+(MOVD 'EQL 'EQN)
+
+(MOVD 'INTEGERP 'FIXP)
+
+(MOVD '+ 'PLUS)
+
+(MOVD '- 'MINUS)
+(MOVD '- 'DIFFERENCE)
+
+(MOVD '* 'TIMES)
+
+(MOVD '/ 'QUOTIENT)
+
+(MOVD 'REM 'REMAINDER)
+
+(MOVD '> 'GREATERP)
+
+(MOVD '< 'LESSP)
+
+(MOVD '>= 'GEQ)
+
+(MOVD '<= 'LEQ)
+
+(MOVD 'LOGIOR 'LOGOR)
+
+(MOVD 'SHIFT 'RSH)
+
+
+;	Section 14:  Input/Output Functions
+
+(MOVD 'READ-CHAR 'READCH)
+
+;READLINE []  reads a line from the terminal and returns it as a list.
+
+(DEFUN READLINE (
+    READ-CHAR RDS )
+  (SETQ READ-CHAR T)			;Set line edit mode
+  (READLINE-AUX (READ-CHAR T)) )
+
+(DEFUN READLINE-AUX (CHAR)
+  ((EQ CHAR (ASCII 13)) NIL)
+  ((EQ CHAR '"]") NIL)
+  ((EQ CHAR '")") NIL)
+  ((EQ CHAR '" ")
+    (SETQ CHAR (READ-CHAR T))
+    ((EQ CHAR (ASCII 13))
+      (PRIN1 '"...")
+      (READLINE-AUX (READ-CHAR T)) )
+    (READLINE-AUX CHAR) )
+  (CONS (READ) (READLINE-AUX (READ-CHAR T))) )
+
+
+;PRIN2 [object]  outputs <object> to the COS putting double quote marks
+;around names containing special characters.
+
+(DEFUN PRIN2 (OBJ
+    PRIN1 )
+  (SETQ PRIN1)
+  (PRIN1 OBJ) )
+
+
+;TAB [n, m]  outputs <m> spaces (1 if <m> is NIL) and then outputs
+;enough spaces to move to column <n>.
+
+(DEFUN TAB (NUM1 NUM2)
+  ( ((NULL NUM2)
+      (SPACES 1) )
+    (SPACES NUM2) )
+  (SPACES (DIFFERENCE NUM1 (SPACES))) )
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/LESSONS.LSP b/Microsoft muLISP-86 v51/LESSONS.LSP
new file mode 100644
index 0000000..75b9526
--- /dev/null
+++ b/Microsoft muLISP-86 v51/LESSONS.LSP	
@@ -0,0 +1,195 @@
+; File:  LESSONS.LSP  (c)	12/29/85	Soft Warehouse, Inc.
+
+
+;		The muLISP Tutorial System Lesson Driver
+
+(PROGN  (WRITE-BYTE 13)
+	(SPACES 2)
+	(TERPRI)
+	(WRITE-STRING "Loading the muLISP Tutorial System: ")
+	(LOOP
+	  (EVAL (READ))
+	  (PRINC '*) ) )
+
+(SETQ *LESSON-DRIVE* '||)
+
+(DEFUN LESSONS (
+    NUM LEFT-COLUMN )
+  (WRS)
+  (SETQ DEFAULT-LESSON 1)
+  (LOOP
+    (RDS)
+    (MOVD 'APP# 'APPEND)
+    (MOVD 'REV# 'REVERSE)
+    (MOVD 'MBR# 'MEMBER)
+    (CLEAR-SCREEN)
+    (SETQ *HIGH-INTENSITY* T)
+    (CENTER "m u L I S P - 8 5")
+    (TERPRI)
+    (CENTER "T U T O R I A L   S Y S T E M")
+    (SETQ *HIGH-INTENSITY*)
+    (SETQ LEFT-COLUMN (MAX 0 (- (TRUNCATE (CADDDR (MAKE-WINDOW)) 2) 22)))
+    (SET-CURSOR 5 LEFT-COLUMN)
+    (WRITE-STRING "Lesson		   Subject")
+    (DISPLAY-MENU SUBJECT-LIST 7 LEFT-COLUMN)
+    (TERPRI 2)
+    (PRINC "When this program asks you to select ")
+    (PRINC "from a list of options and you are not")
+    (PRINC "sure which one to choose, press the ")
+    (PRINC "SPACE BAR for the best default option.")
+    (TERPRI 2)
+    (PRINC "Enter desired lesson number or press \"Q\" ")
+    (PRINC "to quit: ")
+    (SETQ DEFAULT-LESSON (QUERY (LIST* DEFAULT-LESSON 'Q '(1 2 3 4 5 6))))
+    ((EQ DEFAULT-LESSON 'Q)
+	(SYSTEM) )
+    (CATCH NIL (READ-LESSON (PACK* 'MULISP DEFAULT-LESSON)))
+    (SETQ DEFAULT-LESSON (IF
+      (EQ DEFAULT-LESSON (LENGTH SUBJECT-LIST))
+      1
+      (ADD1 DEFAULT-LESSON) )) ) )
+
+(SETQ SUBJECT-LIST '(
+  "Data objects and primitive functions"
+  "Defining functions using recursion"
+  "Symbols, numbers, and conses"
+  "List processing & iterative functions"
+  "Numerical programming techniques"
+  "Implementing turtle graphics routines"
+))
+
+(DEFUN READ-LESSON (FILE-NAME
+    EXPN PTRLST BRKFLG)
+  ((EQ (RDS (PACK* *LESSON-DRIVE* FILE-NAME ".LES")))
+    ((EQ *LESSON-DRIVE* "A:")
+      (TERPRI)
+      (PRINC "Enter the drive that contains the file ")
+      (PRINC (PACK* FILE-NAME ".LES: "))
+      (SETQ *LESSON-DRIVE* (QUERY '(Q A B C D E F G H I J K L M N O P)))
+      ((EQ *LESSON-DRIVE* 'Q))
+      (SETQ *LESSON-DRIVE* (PACK* *LESSON-DRIVE* '\:))
+      (READ-LESSON FILE-NAME) )
+    (SETQ *LESSON-DRIVE* "A:")
+    (READ-LESSON FILE-NAME) )
+  (READPTR 0)
+  (LOOP
+    ( ((EQ (PEEK-CHAR) '$)
+	(READ-CHAR)
+	(EVAL (READ)) ) )
+    ((EQ (READ-LINE) 'CLRSCRN)) )
+  (CLEAR-SCREEN)
+  (PUSH (READPTR) PTRLST)
+  (LOOP
+    ((NOT (LISTEN)))
+    ( ((EQ (PEEK-CHAR) '$)
+	(SETQ ECHO T)
+	(PRINC (READ-CHAR))
+	(SETQ EXPN (READ)
+	      ECHO)
+	((EQ (CAR EXPN) 'DEFUN)
+	  (EVAL EXPN) )
+	(TERPRI)
+	(PRINC (EVAL EXPN)) )
+      ((EQ (SETQ EXPN (READ-LINE)) 'CONTINUE)
+	( ((EQ (CDR PTRLST))
+	    (LBREAK '("Continue lesson" "Abort lesson"))
+	    (PUSH (READPTR) PTRLST) )
+	  ((EQ BRKFLG)
+	    ((LBREAK '("Continue lesson" "Abort lesson" "Previous screen"))
+	      (PUSH (READPTR) PTRLST) )
+	    (POP PTRLST)
+	    (READPTR (CAR PTRLST)) )
+	  ((LBREAK '("Continue lesson" "Break lesson" "Abort lesson"
+		"Previous screen"))
+	    (PUSH (READPTR) PTRLST) )
+	  (POP PTRLST)
+	  (READPTR (CAR PTRLST)) )
+	(CLEAR-SCREEN) )
+      ((EQ EXPN 'BREAK)
+	(SETQ BRKFLG T)
+	((LBREAK '("Break lesson" "Continue lesson" "Abort lesson"
+		"Previous screen")) )
+	(POP PTRLST)
+	(READPTR (CAR PTRLST))
+	(CLEAR-SCREEN) )
+      ((EQ EXPN 'CLRSCRN)
+	(PUSH (READPTR) PTRLST)
+	(CLEAR-SCREEN) )
+      (WRITE-LINE EXPN) ) ) )
+
+(DEFUN LBREAK (LST
+    CHAR RDS WRS READ-CHAR)
+  (SETQ CHAR (OPTIONS LST))
+  ((EQ CHAR 'A)
+    (THROW) )
+  ((EQ CHAR 'C))
+  ((EQ CHAR 'P) NIL)
+  ((EQ CHAR 'B)
+    (SETQ READ-CHAR 'READ-CHAR)
+    (CATCH NIL (DRIVER))
+    (RDS (PACK* *LESSON-DRIVE* FILE-NAME ".LES")) )
+  ((EQ CHAR 'S)
+    (SYSTEM) ) )
+
+(DEFUN OPTIONS (LST1
+    LST2 *PRINT-DOWNCASE* WRS)
+  (WRITE-BYTE 13)
+  (LOOP
+    (PUSH (CAR (UNPACK (PRINC (POP LST1)))) LST2)
+    ((EQ LST1))
+    (WRITE-STRING ", ") )
+  (WRITE-STRING " (")
+  (SETQ LST2 (REV# LST2)
+	LST1 LST2)
+  (LOOP
+    (PRINC (POP LST1))
+    ((EQ LST1))
+    (PRINC '/) )
+  (WRITE-STRING ")? ")
+  (QUERY LST2) )
+
+(DEFUN QUERY (LST
+    RDS READ-CHAR CHAR)
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    (IF (<= 48 (ASCII CHAR) 57)
+	(SETQ CHAR (- (ASCII CHAR) 48)))
+    ((MBR# CHAR LST)
+      (PRINC CHAR)
+      (TERPRI)
+      CHAR )
+    ((EQ CHAR '" ")
+      (PRINC (CAR LST))
+      (TERPRI)
+      (CAR LST) )
+    ( ((EQ CHAR (ASCII 10)))
+      ((EQ BELL))
+      (WRITE-BYTE 7) ) ) )
+
+(DEFUN DISPLAY-MENU (OPTION-LIST ROW COLUMN
+    NUM )
+  (SETQ NUM 0)
+  (IF (> (CADDDR (MAKE-WINDOW)) 50)
+	(INCQ COLUMN 3) )
+  (LOOP
+    ((EQ OPTION-LIST))
+    (SET-CURSOR (+ ROW NUM) COLUMN)
+    (PRINC (INCQ NUM))
+    (SPACES 1)
+    (IF (> (CADDDR (MAKE-WINDOW)) 50) (SPACES 3))
+    (WRITE-LINE (POP OPTION-LIST)) ) )
+
+(DEFUN CENTER (MSG)
+  (SET-CURSOR (ROW)
+	(TRUNCATE (- (CADDDR (MAKE-WINDOW)) (LENGTH MSG)) 2))
+  (WRITE-LINE MSG) )
+
+(MOVD 'REVERSE 'REV#)
+(MOVD 'MEMBER 'MBR#)
+(MOVD 'APPEND 'APP#)
+
+(SETQ DRIVER 'LESSONS)
+
+(RETURN)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/METAMIND.LSP b/Microsoft muLISP-86 v51/METAMIND.LSP
new file mode 100644
index 0000000..df2e6df
--- /dev/null
+++ b/Microsoft muLISP-86 v51/METAMIND.LSP	
@@ -0,0 +1,276 @@
+;File:	METAMIND.LSP		12/29/85	Soft Warehouse, Inc.
+
+
+(LOOP (PRIN1 '*) (EVAL (READ)) ((NULL RDS)) )
+
+(DEFUN METAMIND (
+    KEYLIST HELPMK HELPBR SEED)
+  (CLEAR-SCREEN)
+  (TERPRI)
+  (CENTER "* * *   T H E   M E T A M I N D   G A M E   * * *")
+  (TERPRI 2)
+  (CENTER "Break the secret code using pure logic.")
+  (TERPRI 3)
+  (SETQ KEYLIST '(
+    (BLU GRN WHI YEL RED BLK)
+    (RED YEL GRN BLK BLU WHI)
+    (BLK BLU YEL GRN WHI RED)
+    (YEL WHI RED BLK BLU GRN)
+      ))
+  (LOOP
+    (PRINC "Please enter a random number between 1 and 100: ")
+    ((PLUSP (SETQ SEED (RATOM))))
+    (TERPRI) )
+  (TERPRI)
+  (LOOP
+    (PRINC "Would you like to be the code Maker or Breaker? (M/B) ")
+    ( ((EQ (QUERY '(M B)) 'M)
+	(TERPRI)
+	(HELPMK)
+	(CODEBREAKER) )
+      (TERPRI)
+      (HELPBR)
+      (CODEMAKER) )
+    (TERPRI)
+    ((NOT (Y-OR-N-P "Do you want to play another round?")))
+    (TERPRI 2) ) )
+
+(DEFUN HELPMK ()
+  ((EVAL HELPMK))
+  (SETQ HELPMK T)
+  (CENTER "So you want to challenge the champ!")
+  (TERPRI 2)
+  (PRINTC "Ok, after I make my guess, you type in the number of blacks")
+  (PRINTC "(i.e. the number of guesses of the right color and right column),")
+  (PRINTC "a space, and then the number of whites (i.e. of the remaining")
+  (PRINTC "non-black guesses, the number of correct colors).  Then press")
+  (PRINTC "the <RETURN> key.")
+  (TERPRI) )
+
+(DEFUN HELPBR (CTR)
+  ((EVAL HELPBR))
+  (SETQ HELPBR T)
+  (PRINTC "So you want to out guess me.  Let me think of a code")
+  (SETQ CTR 800)
+  (PRIN1 "Hmmm . ")
+  (LOOP
+    ((ZEROP CTR))
+    ( ((ZEROP (REM CTR 150)) (PRIN1 ". ")) )
+    (DECQ CTR) )
+  (TERPRI 2)
+  (PRINTC "Ok, I have got one, now make a guess by typing in 4 of the")
+  (PRINC "colors in the following list of colors:  ")
+  (PRINT (CAR KEYLIST))
+  (TERPRI) )
+
+
+(DEFUN CODEBREAKER (
+    MOVE GRAPH CTR KEYLST NUM)
+  (SETQ KEYLIST (MAPCAR 'PERMUTE KEYLIST))
+  (SETQ MOVE (FRSTMOV (CAR KEYLIST)))
+  (SETQ GRAPH (NUGRAPH MOVE))
+  (SETQ CTR 1)
+  (LOOP
+    (SPACES (TRUNCATE (- (LINELENGTH) 32) 2))
+    (PRINC "Move: ")
+    (PRINC CTR)
+    (SPACES 3)
+    (MAPC '(LAMBDA (COLOR) (PRIN1 COLOR) (SPACES 2)) MOVE)
+    (SETQ NUM (RATOM))
+    ((EQ NUM 4)
+      (CLEAR-INPUT)
+      (TERPRI)
+      (PRINTC "Yea, I did it!  And it only took me " CTR " moves.")
+      (TERPRI) )
+    (SETQ GRAPH (MKGRAPH MOVE NUM (RATOM) MOVE NIL GRAPH KEYLIST))
+    (INCQ CTR)
+    (SETQ ERROR NIL)
+    (SETQ KEYLST KEYLIST)
+    (SETQ MOVE (MKMOVE GRAPH (POP KEYLST)))
+    (TERPRI)
+    ((EVAL ERROR)
+      (PRINTC "I am afraid you have made a mistake in your counting.")
+      (PRINTC "Let's start over.") ) ) )
+
+(DEFUN PERMUTE (LST1 LST2 LST3)
+  ((NULL LST1)
+    (NCONC LST2 LST3) )
+  ((NULL (CDR LST1))
+    (NCONC (CONS (CAR LST1) LST3) LST2) )
+  ((NULL (CDDR LST1))
+    (NCONC (PERMUTE (CONS (CAR LST1) LST2))
+	   (PERMUTE (CONS (CADR LST1) LST3))) )
+  (PERMUTE (CDDDR LST1) (CONS (CADR LST1) LST3)
+	 (LIST* (CADDR LST1) (CAR LST1) LST2)) )
+
+
+(DEFUN FRSTMOV (KEY)
+  (LIST (CAR KEY) (CADDR KEY) (CAR KEY) (CADDR KEY)) )
+
+(DEFUN NUGRAPH (MOVE)
+  ((NULL MOVE) T)
+  (NUROW (NUGRAPH (CDR MOVE)) (CAR KEYLIST)) )
+
+(DEFUN NUROW (GRAPH KEY)
+  ((NULL KEY) NIL)
+  (CONS GRAPH (NUROW GRAPH (CDR KEY))) )
+
+(DEFUN MKMOVE (GRAPH KEY)
+  (LOOP
+    ((NULL GRAPH)
+      (SETQ ERROR T) NIL)
+    ((CAR GRAPH)
+      ((ATOM (CAR GRAPH))
+	(LIST (CAR KEY)) )
+      (CONS (CAR KEY) (MKMOVE (CAR GRAPH) (POP KEYLST))) )
+    (POP GRAPH)
+    (POP KEY) ) )
+
+(DEFUN MKGRAPH (MOVE BLACKS WHITES FREE UNUSED GRAPH KEYLST)
+  ((NULL MOVE)
+    ((ZEROP BLACKS)
+      (EQ WHITES (INCOMMON FREE UNUSED)) ) )
+  (MKNODE GRAPH (CAR KEYLST)) )
+
+(DEFUN MKNODE (GRAPH KEY)
+  ((NULL KEY) NIL)
+  ((NULL (CAR GRAPH))
+    (CONSNIL (MKNODE (CDR GRAPH) (CDR KEY))) )
+  ((EQ (CAR MOVE) (CAR KEY))
+    ((PLUSP BLACKS)
+      (CONSNULL (MKGRAPH (CDR MOVE) (SUB1 BLACKS) WHITES
+	(REMBER1 (CAR KEY) FREE) UNUSED (CAR GRAPH) (CDR KEYLST))
+	  (MKNODE (CDR GRAPH) (CDR KEY))) )
+    (CONSNIL (MKNODE (CDR GRAPH) (CDR KEY))) )
+  (CONSNULL (MKGRAPH (CDR MOVE) BLACKS WHITES FREE
+    (CONS (CAR KEY) UNUSED) (CAR GRAPH) (CDR KEYLST))
+      (MKNODE (CDR GRAPH) (CDR KEY))) )
+
+
+(DEFUN CODEMAKER (CODE MOVE CTR)
+  (SETQ KEYLIST (MAPCAR 'PERMUTE KEYLIST))
+  (SETQ CODE (MKCODE KEYLIST))
+  (SETQ CTR 1)
+  (LOOP
+    (SPACES (TRUNCATE (- (LINELENGTH) 32) 2))
+    (PRIN1 "Move: ")
+    (PRIN1 CTR)
+    (SPACES 3)
+    ((CODEMATCH CODE (READMOVE CODE) 0)
+      (TERPRI)
+      (PRINTC "That took you " CTR (COND
+		((EQ CTR 1) " move.")
+		(" moves.") ) )
+      ((< CTR 6)
+	(PRINTC "Hey you're good, let's play again!") )
+      ((< CTR 8)
+	(PRINTC "That was a hard one, want to try to improve your score?") )
+      (PRINTC "Better take a break and let me be the code breaker.") )
+    (TERPRI)
+    (INCQ CTR) ) )
+
+(DEFUN MKCODE (KEYLST)
+  ((NULL KEYLST) NIL)
+  (CONS (NTH (RANDOM 4) (CAR KEYLST)) (MKCODE (CDR KEYLST))) )
+
+(DEFUN CODEMATCH (CODE1 MOVE1 BLACKS CODE2 MOVE2)
+  ((NULL CODE1)
+    (SPACES (+ (TRUNCATE (- (LINELENGTH) 32) 2) 28))
+    ((EQ (PRIN1 BLACKS) 4))
+    (SPACES 2)
+    (SAMETYPE CODE2 MOVE2 0)
+    NIL )
+  ((EQ (CAR CODE1) (CAR MOVE1))
+    (CODEMATCH (CDR CODE1) (CDR MOVE1) (ADD1 BLACKS) CODE2 MOVE2) )
+  (CODEMATCH (CDR CODE1) (CDR MOVE1) BLACKS (CONS (CAR CODE1) CODE2)
+    (CONS (CAR MOVE1) MOVE2)) )
+
+(DEFUN SAMETYPE (CODE MOVE WHITES)
+  ((NULL CODE)
+    (PRINT WHITES) )
+  ((MEMBER (CAR CODE) MOVE)
+    (SAMETYPE (CDR CODE) (REMBER1 (CAR CODE) MOVE) (ADD1 WHITES)) )
+  (SAMETYPE (CDR CODE) MOVE WHITES) )
+
+(DEFUN READMOVE (CODE)
+  ((NULL CODE) NIL)
+  (CONS (RATOM) (READMOVE (CDR CODE))) )
+
+(DEFUN CONSNULL (X Y)
+  ((NULL X)
+    ((NULL Y) NIL)
+    (CONS NIL Y) )
+  (CONS X Y) )
+
+(DEFUN CONSNIL (X)
+  ((NULL X) NIL)
+  (CONS NIL X) )
+
+(DEFUN INCOMMON (LST1 LST2
+    TOT )
+  (SETQ TOT 0)
+  (LOOP
+    ((OR (NULL LST1) (NULL LST2)) TOT)
+    ( ((MEMBER (CAR LST1) LST2)
+	(SETQ LST2 (REMBER1 (CAR LST1) LST2))
+	(INCQ TOT) ) )
+    (POP LST1) ) )
+
+(DEFUN REMBER1 (X L)
+  ((NULL L) NIL)
+  ((EQ X (CAR L)) (CDR L))
+  (CONS (CAR L) (REMBER1 X (CDR L))) )
+
+(DEFUN REPLACE (X Y L)
+  ((NULL L) NIL)
+  ((EQ X (CAR L))
+    (CONS Y (REPLACE X Y (CDR L))) )
+  (CONS (CAR L) (REPLACE X Y (CDR L))) )
+
+(DEFUN RANDOM (NUM)
+  (SETQ SEED (REM (+ 2113233 (* SEED 271821)) 9999991))
+  (REM SEED NUM) )
+
+(DEFUN Y-OR-N-P (MSG
+    CHAR READ-CHAR RDS WRS )
+  ( ((NULL MSG))
+    (FRESH-LINE)
+    (WRITE-STRING (PACK* MSG " (Y/N) ")) )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-CHAR)))
+    ((EQ CHAR 'Y)
+      (WRITE-LINE CHAR)
+      T )
+    ((EQ CHAR 'N)
+      (WRITE-LINE CHAR)
+      NIL )
+    (WRITE-BYTE 7) ) )
+
+(DEFUN QUERY (LST
+     CHAR RDS )
+  (CLEAR-INPUT)
+  (LOOP
+    (SETQ CHAR (CHAR-UPCASE (READ-KEY)))
+    ((MEMBER CHAR LST)
+      (PRINC CHAR)
+      (TERPRI)
+      CHAR )
+    (PRIN1 (ASCII 7)) ) )
+
+(DEFUN READ-KEY (
+    READ-CHAR RDS)
+  (READ-CHAR) )
+
+(DEFUN PRINTC LST
+  (PRINC (PACK LST))
+  (TERPRI)
+  'T )
+
+(DEFUN CENTER (MSG)
+  (SET-CURSOR (ROW)
+	(TRUNCATE (- (CADDDR (MAKE-WINDOW)) (LENGTH MSG)) 2))
+  (WRITE-LINE MSG) )
+
+(METAMIND (RDS))
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MOUSE.LSP b/Microsoft muLISP-86 v51/MOUSE.LSP
new file mode 100644
index 0000000..62335d4
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MOUSE.LSP	
@@ -0,0 +1,59 @@
+; File:  MOUSE.LSP		12/29/85	Soft Warehouse, Inc.
+
+;		Microsoft Mouse Interface Functions
+
+; This file requires that the Microsoft Mouse hardware and device driver
+; software be properly installed.
+; The functions automatically update the following global variables:
+
+; *MOUSE-ROW*       the vertical mouse position
+; *MOUSE-COL*       the horizontal mouse position
+; *LEFT-BUTTON*     T if and only if left button pressed
+; *RIGHT-BUTTON*    T if and only if right button pressed
+; *BUTTON-PRESSES*  the number of button presses
+; *BUTTON-RELEASES* the number of button releases
+
+(DEFUN SHOW-MOUSE ()			;Display mouse cursor
+  (REGISTER 0 1)
+  (INTERRUPT 51) )
+
+(DEFUN HIDE-MOUSE ()			;Hide mouse cursor
+  (REGISTER 0 2)
+  (INTERRUPT 51) )
+
+(DEFUN POSITION-MOUSE (ROW COL)		;Current mouse position
+  ((AND (INTEGERP ROW) (INTEGERP COL))
+    (REGISTER 0 4)
+    (REGISTER 2 COL)
+    (REGISTER 3 ROW)
+    (INTERRUPT 51) )
+  (REGISTER 0 3)
+  (INTERRUPT 51)
+  (SETQ *MOUSE-ROW* (REGISTER 3))
+  (SETQ *MOUSE-COL* (REGISTER 2)) )
+
+(DEFUN STATUS-MOUSE ()			;Current button status
+  (REGISTER 0 3)
+  (INTERRUPT 51)
+  (SETQ *LEFT-BUTTON* (ODDP (REGISTER 1)))
+  (SETQ *RIGHT-BUTTON* (ODDP (SHIFT (REGISTER 1) -1))) )
+
+(DEFUN BUTTON-PRESS (BUTTON)		;Mouse status at last button press
+  (REGISTER 0 5)
+  (SETQ *BUTTON-PRESSES* (BUTTON-INFO)) )
+
+(DEFUN BUTTON-RELEASE (BUTTON)		;Mouse status at last button release
+  (REGISTER 0 6)
+  (SETQ *BUTTON-RELEASES* (BUTTON-INFO)) )
+
+(DEFUN BUTTON-INFO ()
+  (REGISTER 1 (IF (EQ BUTTON 'LEFT) 0 1))
+  (INTERRUPT 51)
+  (SETQ *LEFT-BUTTON* (ODDP (REGISTER 0)))
+  (SETQ *RIGHT-BUTTON* (ODDP (SHIFT (REGISTER 0) -1)))
+  (SETQ *MOUSE-ROW* (REGISTER 3))
+  (SETQ *MOUSE-COL* (REGISTER 2))
+  (REGISTER 1) )
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP.COM b/Microsoft muLISP-86 v51/MULISP.COM
new file mode 100644
index 0000000000000000000000000000000000000000..6d8933569c0dd0c2f1e57ceb470589862b6671fa
GIT binary patch
literal 38729
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

literal 0
HcmV?d00001

diff --git a/Microsoft muLISP-86 v51/MULISP1.LES b/Microsoft muLISP-86 v51/MULISP1.LES
new file mode 100644
index 0000000..3e4ed22
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP1.LES	
@@ -0,0 +1,341 @@
+File:  MULISP1.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is the first of a series of on-line lessons designed to teach the
+fundamentals of LISP programming using the muLISP dialect of LISP.
+
+muLISP is a powerful programming language rich in control constructs and
+functions for operating on user created data structures.  However there is a
+small subset of muLISP, hereafter called pure muLISP, that illustrates many of
+the fundamental programming concepts required to understand muLISP.
+
+The first two programming lessons are devoted to teaching pure muLISP.  A
+systematic presentation of the full power of muLISP begins with the third
+lesson.
+
+
+CONTINUE
+muLISP is a symbolic programming language.  Most conventional programming
+languages are primarily designed for numerical processing.  Rather than
+manipulating numerical data structures (like numbers and arrays), muLISP
+programs typically manipulate symbolic data structures (like words and
+sentences).
+
+In muLISP virtually any symbolic data structure can be represented as an
+object.  We will begin these lessons by describing what constitutes an object
+and how objects can be used to represent symbolic data structures.  After
+that, we will describe how to use muLISP to manipulate these objects.
+
+
+CONTINUE
+Data objects can be either simple or composite.  Simple data objects are
+called atoms.  In pure muLISP, atoms are indivisible in the sense that they
+cannot be divided into sub-components.  Like people, atoms are referred to by
+name.  Atom names consists of a string of characters.  The following are four
+typical atom names:
+
+       APPLE    RABBIT    54321    -41
+
+Composite data objects are called lists.  Lists are made up of zero or more
+objects, each of which can be simple or composite.  Lists are entered and
+displayed with their elements enclosed in parentheses.  The following is a
+list consisting of four elements:
+
+	   (THE QUICK BROWN FOX)
+
+
+CONTINUE
+We stated earlier that muLISP is a symbolic programming language because it
+manipulated symbolic data structures.  muLISP is also a functional programming
+language because functions are used to manipulate the symbolic data
+structures.
+
+Given an ordered set of data objects, a muLISP function will return a unique
+value based upon the data objects it is given.  Pure muLISP provides 5
+primitive functions for manipulating the primitive data objects (i.e. atoms
+and lists).  Writing muLISP "programs" consists of defining additional
+functions to perform some desired task.
+
+We will begin the lessons by showing the mechanics of interacting with muLISP.
+Then we examine the use of each of the 5 primitive functions.  Once you have
+mastered the use of these primitives, you will be ready to begin lesson 2 to
+learn how to define your own functions in terms of the primitive functions.
+
+
+CONTINUE
+In some ways interacting with muLISP is much like using a pocket calculator.
+First you enter an expression following the dollar sign prompt, then muLISP
+reads the expression, evaluates it, and displays the result.  To prevent the
+evaluation of an expression, you must precede the expression with a SINGLE
+QUOTE MARK (also called the apostrophe or accent mark).  Do not confuse this
+with the BACK ACCENT mark found on some keyboards.  The following shows what
+happens when the atom name APPLE is entered:
+
+$ 'APPLE
+
+If an atom name is entered without the quote mark, the value of the atom is
+returned.  In pure muLISP atoms evaluate to themselves.  Therefore the quote
+mark before atoms is often not necessary:
+
+$ APPLE
+
+To enter atom names of your own, select the Break option by pressing B.  When
+you are ready to return to the lesson, following the dollar sign prompt, type
+(RETURN) and press the <RETURN> key.
+
+BREAK
+CLRSCRN
+Lists are entered by enclosing the elements within matching parentheses.  The
+following shows how to enter a list:
+
+$ '(CAT COW DOG PIG)
+
+The elements of a list can themselves be lists.  For instance, the following
+list might be part of a data structure describing someone:
+
+$ '((HEIGHT 72) (WEIGHT 175) (EYES BLUE) (HAIR BLOND))
+
+If you should forget to precede the list with a single quote mark, you will
+invoke an "Undefined Function" error.  If this should occur, select the
+Continue option by pressing C and the error will be ignored.
+
+Press B and try entering some lists of your own.  When you are ready to return
+to the lesson, type (RETURN) and press the <RETURN> key.
+
+BREAK
+CLRSCRN
+LISP is an acronym for LISt Processing language.  Thus as you might expect,
+muLISP provides primitive functions for operating on lists of objects.  One of
+the most common operations is the extraction or selection of one the members
+of a list so that it can be examined independently.  Functions that perform
+this service are called selector functions.
+
+Two of the five primitive pure muLISP functions are selector functions.  The
+CAR function returns the first element of a list.  The CDR (pronounced
+could-er) function returns everything except the first element of a list.
+
+The nonmnemonic names of these two functions is derived from the original
+implementation of LISP on an IBM 704 computer in the early 1960's.  As we
+shall see in later lessons, these function names turn out to be convenient
+despite their now irrelevant origin.
+
+
+CONTINUE
+In muLISP, functions calls are made using the format
+
+		  (name arg1 arg2 ...)
+
+where <name> is the function's name, <arg1> is the first argument, <arg2> is
+the second, etc.
+
+Note that the left parenthesis precedes the function's name rather than
+following it as is customary in mathematics and other programming languages.
+This notational peculiarity alone has probably caused more grief for the
+novice LISP programmer than any other single thing.  However, as you become
+more familiar with LISP the justification for this unusual notation will
+become apparent and seem quite natural.
+
+
+CONTINUE
+Remember that the function CAR returns the first element of a list.  Rather
+than say "the first element of" a list, most LISP programmers say "the CAR of"
+a list.
+
+The following example shows how to find the CAR of the list (DOG CAT COW PIG):
+
+$ (CAR '(DOG CAT COW PIG))
+
+During this Break use the function CAR to determine the CAR of the list
+((RAM 256) (ROM 64) (DISK 322)).  Be sure to i) type the function CAR using
+all capital letters, ii) precede the list with a single quote mark, and iii)
+balance your parentheses.  muLISP ignores extra RIGHT parentheses so you can
+include a few extra at the right end of an expression.
+
+When you are ready to return to the lesson, type (RETURN) and press the
+<RETURN> key.
+
+BREAK
+CLRSCRN
+The function CDR returns everything but the CAR of a list.  The phrase "the
+CDR of" a list is used instead of the more cumbersome "everything but the
+first element of" a list.
+
+The following example shows how to find the CDR of the list (DOG CAT COW PIG):
+
+$ (CDR '(DOG CAT COW PIG))
+
+During this break use the function CDR to determine the CDR of the list
+((HEIGHT 72) (WEIGHT 175) (HAIR BLOND)).
+
+When you are ready to return to the lesson, type (RETURN) and press the
+<RETURN> key.
+
+BREAK
+CLRSCRN
+Up to now the arguments given to functions have been quoted objects.  However,
+there is no reason the value returned by one function call cannot be used as
+the argument to another function call.
+
+Consider how to select the second element of a list.  The CDR of a list is a
+list consisting of everything but the first element of the original list.
+Thus the CAR of the CDR of a list is the second element of the list.  The
+following shows how to find the second element of the list (DOG CAT COW PIG):
+
+$ (CAR (CDR '(DOG CAT COW PIG)))
+
+Using combinations of CAR and CDR extract from the list
+((HEIGHT 72) (WEIGHT 175) (HAIR BLOND))  the sublist (WEIGHT 175)  [note that
+(WEIGHT 175) is the second element of the list].  Then try to extract from the
+same list just the atom 175 [note that 175 is the second element of the second
+element of the list].
+
+BREAK
+In case you had trouble, here is how to get the 175:
+
+$ (CAR (CDR (CAR (CDR '((HEIGHT 72) (WEIGHT 175) (HAIR BLOND)) ))))
+
+
+CONTINUE
+CAR and CDR are called selector functions because they are used to select or
+extract the parts of an object.  Constructor functions perform the
+complementary operation of constructing composite objects from simpler
+objects.
+
+One of the five primitive pure muLISP functions is the constructor function
+CONS.  CONS is used to add objects to the front of an existing list.  Its
+first argument is the object to be added; its second argument is the existing
+list.  For example:
+
+$ (CONS 'DOG '(CAT COW PIG))
+
+Try adding (EYES BROWN) to ((HEIGHT 72) (WEIGHT 175) (HAIR BLOND)).  Make sure
+you balance the parentheses around each argument to CONS.
+
+BREAK
+CLRSCRN
+Note that the CAR of the result returned by CONS will always be the first
+argument to CONS.  Similarly the CDR of the result will always be the second
+argument.  For example:
+
+$ (CAR (CONS 'DOG '(CAT COW PIG)))
+
+$ (CDR (CONS 'DOG '(CAT COW PIG)))
+
+See if you can CONS the CAR of the list (A B C) onto the CDR of the list
+(X Y Z) resulting in the list (A Y Z).  Again make sure you balance the
+parentheses around each argument to CONS.
+
+BREAK
+The correct answer to the last problem is:
+
+$ (CONS (CAR '(A B C)) (CDR '(X Y Z)))
+
+
+CONTINUE
+In order to make some sense out of muLISP programs it is essential that you
+learn to "read" function compositions such as the one above.  This example
+should be read as "the CONS of the CAR of the list (A B C) onto the CDR of the
+list (X Y Z)".
+
+Use muLISP to find the CONS of the CAR of the CDR of the list
+(A B C) onto the list (X Y Z).  Don't forget to balance those parentheses.
+
+BREAK
+The correct answer to the last problem is:
+
+$ (CONS (CAR (CDR '(A B C))) '(X Y Z))
+
+
+CONTINUE
+As mentioned earlier, a muLISP data object is either an atom or a list.  Also
+we explained that the CAR of a list is the first element of the list.  What
+then is the CAR of an atom?  Although it is a well-defined operation that does
+not cause an error, in pure muLISP CAR should not be called with an atomic
+argument.
+
+For this and other reasons, we need some way of recognizing whether an object
+is an atom or a list.  The fourth primitive muLISP function we shall discuss
+is the recognizer function ATOM.  ATOM is a function of one argument.  If its
+argument is an atom, ATOM returns the atom T for true; otherwise ATOM returns
+the atom NIL for false.  For example:
+
+$ (ATOM 'APPLE)
+
+$ (ATOM '(DOG CAT COW PIG))
+
+Use the ATOM function to see whether numbers are atoms or not.
+
+BREAK
+CLRSCRN
+Consider the following ATOM test:
+
+$ (ATOM '())
+
+As should be evident by the above example, the empty "list" is not a list at
+all, but an atom!  In fact, muLISP represents the empty list by the atom NIL.
+Thus:
+
+$ '()
+
+Try using muLISP to find the CDR of the single element list '(APPLE).
+
+BREAK
+CLRSCRN
+The last primitive pure muLISP function is EQL.  It is a comparator function
+useful for determining if its two atomic arguments are the same atom.  For
+example:
+
+$ (EQL 'ROM 'RAM)
+
+$ (EQL (CAR '(DOG CAT COW)) (CAR (CDR '(HORSE DOG PIG))))
+
+Using the functions CAR, CDR, and EQL, see if the weight specified in the
+list ((HEIGHT 72) (WEIGHT 175) (HAIR BLOND))  [i.e. the second element of
+the second element of the list]  is 175.  Note that there is no need to
+quote numbers in muLISP, although it is acceptable.
+
+BREAK
+Here is how to check the weight equal to 175:
+
+$ (EQL 175 (CAR (CDR (CAR (CDR '((HEIGHT 72) (WEIGHT 175) (HAIR BLOND)))))))
+
+
+CONTINUE
+As stated when EQL was introduced, EQL is useful only for comparing
+atomic arguments (this statement is not always true in "impure" muLISP).  If
+given lists as arguments (except of course the empty list, which is an atom
+anyway), EQL will always return NIL.  For example:
+
+$ (EQL '(DOG CAT COW) '(DOG CAT COW))
+
+One of the projects in the next lesson will be to define a function called
+EQLIST that is useful for determining the equality of two lists.
+
+
+CONTINUE
+In this lesson we have discussed what constitutes muLISP atoms and lists.
+Collectively these objects are used to make up the symbolic data structure
+that muLISP functions operate on.  Pure muLISP provides the following five
+primitive functions for operating on objects:
+
+1.  (CAR list)  the selector function that returns the first element of
+    <list>;
+
+2.  (CDR list)  the selector function that returns everything but the first
+    element of <list>;
+
+3.  (CONS object list)  the constructor function that returns the list whose
+    CAR is <object> and whose CDR is <list>;
+
+4.  (EQL atom1 atom2)  the comparator function that returns T if <atom1> and
+    <atom2> are the same atom, otherwise it returns NIL;
+
+5.  (ATOM object)  the recognizer function that returns T if <object> is an
+    atom, otherwise it returns NIL.
+
+Congratulations on successfully completing muLISP lesson #1!  In lesson #2 you
+will learn how to write your own muLISP functions.
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP2.LES b/Microsoft muLISP-86 v51/MULISP2.LES
new file mode 100644
index 0000000..7700065
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP2.LES	
@@ -0,0 +1,518 @@
+File:  MULISP2.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is the second of a series of on-line lessons designed to teach the
+fundamentals of LISP programming using the muLISP dialect of LISP.
+
+The first lesson explained in detail the 5 primitive functions in pure muLISP.
+In this lesson you will learn how to add your own functions to the basic
+primitives.
+
+
+CONTINUE
+Like primitive functions, user-defined functions are called with arguments and
+return a single value based upon the arguments.  Naturally a function must be
+defined before it is called with specific arguments.  Thus, there must be some
+means of referring to each of the arguments within the function definition
+before the actual arguments are known.
+
+The name used within a function definition to refer to an as yet unspecified
+ACTUAL ARGUMENT is called a FORMAL ARGUMENT.  A list of a function's formal
+arguments is included at the beginning of its definition.
+
+The next screen will show how formal arguments are used in a definition.
+
+
+CONTINUE
+In pure muLISP, expressions of the following form
+
+   (DEFUN name (arg1 arg2 ...)
+	task1
+	task2
+	 ...  )
+
+are used to define the function named <name>.  The atoms <arg1>, <arg2>, etc.
+are the formal argument names used for referring to the function's actual
+arguments.  The body of the function is made up of one or more tasks.  DEFUN
+stands for DEfine FUNction.
+
+We will postpone a full discussion of the component parts of function
+definitions until a later lesson.  For now, we will show how to define
+functions by example beginning with the next screen.
+
+
+CONTINUE
+Some people prefer a more mnemonic name than CAR for the function that returns
+the first element of a list.  This situation can be easily corrected by the
+following definition:
+
+$ (DEFUN FIRST (LST)
+    (CAR LST) )
+
+Note that the function being defined is named FIRST, that the function takes a
+single argument, that the argument can be referred to by the name LST within
+the function body, and that the function body consists of a single task which
+returns the CAR of the argument.
+
+User-defined functions are called in exactly the same way as the primitive
+functions.  For example:
+
+$ (FIRST '(DOG CAT COW PIG))
+
+
+CONTINUE
+No need to stop with selecting the FIRST element of a list.  Here is a
+definition for selecting the SECOND element of a list:
+
+$ (DEFUN SECOND (LST)
+    (CAR (CDR LST)) )
+
+During this break, using the functions CAR and CDR define the function THIRD
+and try out the functions FIRST, SECOND, and THIRD on some lists.  When
+entering multi-line muLISP expressions, like function definitions, you cannot
+edit the previous line once the <RETURN> key has been pressed.  Thus, make
+sure each line of a definition is correct before continuing to the next.  When
+you are ready to continue the lesson, type (RETURN) and press the <RETURN>
+key.
+
+BREAK
+Here is our definition for THIRD:
+
+$ (DEFUN THIRD (LST)
+    (CAR (CDR (CDR LST))) )
+
+$ (THIRD '(DOG CAT COW PIG))
+
+CONTINUE
+In lesson #1 we learned that the atom NIL is used to represent the empty list.
+NIL was also the atom returned by the functions EQL and ATOM to indicate a
+false truth value.  Since NIL is clearly a very special muLISP atom, it is
+important to be able to recognize it.
+
+What we need is a recognizer function called NULL that returns T if its
+argument is the empty list (i.e. NIL); otherwise it should return NIL.  (From
+now on we will say the "null list" rather than the "empty list".)
+
+During this Break, define the function NULL (you only need to use one of the
+5 primitive functions), and then try your new function out on various atoms
+and lists.
+
+BREAK
+Here is our definition for NULL.  Note that it is not necessary to quote NIL
+in the definition, since the value of NIL is NIL.  If you used () instead of
+NIL in the definition, () does not have to be quoted.
+
+$ (DEFUN NULL (OBJ)
+    (EQL OBJ NIL) )
+
+$ (NULL '(A B C))
+
+$ (NULL ())
+
+CONTINUE
+Up till now each user-defined function has been essentially just an
+abbreviation for the single task that makes up the function body.  But, the
+real power of functions comes from their ability to choose between courses of
+action based upon their arguments.
+
+Currently we have at our disposal three functions that can be used for
+testing arguments.  They are EQL, ATOM, and NULL.  Functions used for testing
+are often called PREDICATES.
+
+The next screen describes how to use predicates to make decisions within
+function definitions.
+
+
+CONTINUE
+As you may recall, a function body consists of one or more tasks.  In pure
+muLISP, tasks can be divided into two classes: simple tasks and conditional
+tasks.  A task which is an atom or a list whose CAR (i.e. first element) is an
+atom is a SIMPLE task.  For example:
+
+		(CONS ATM LST)
+
+The tasks in the functions defined thus far have all been simple tasks.  A
+task which is a list whose CAR is NOT an atom is a CONDITIONAL task.  For
+example:
+
+	 ((ATOM EXPN) (CONS EXPN LST))
+
+The CAR of a conditional task is the conditional's predicate.  If the
+predicate returns NIL, the value of task is also NIL and evaluation of the
+function body proceeds with the next task, if any.  If the predicate returns
+any value other than NIL, the remaining tasks in the function body are ignored
+and evaluation proceeds using the CDR of the conditional task as the remaining
+tasks.
+
+The examples in the next several screens should make this clearer.
+
+CONTINUE
+We already have the function ATOM that returns T if and only if its argument
+is an atom.  However, pure muLISP does not have a similar primitive recognizer
+function for lists.  Why not?  Because we can write our own if we need it.
+
+Since our new function will be a LIST Predicate, let's name it LISTP.  If its
+argument is an atom, LISTP should return NIL.  If the argument is not an atom,
+it must be a list and LISTP should return T.
+
+$ (DEFUN LISTP (OBJ)
+    ((ATOM OBJ) NIL)
+    T )
+
+You can think of the body of this definition as saying:  "If OBJ is an atom,
+return NIL; otherwise return T".
+
+After trying LISTP out on several objects including the null list, redefine
+LISTP so it returns T when given the null list.
+
+BREAK
+Here is LISTP modified to handle the null list:
+
+$ (DEFUN LISTP (OBJ)
+    ((NULL OBJ))
+    ((ATOM OBJ) NIL)
+    T )
+
+$ (LISTP 'DOG)
+
+$ (LISTP '())
+
+$ (LISTP '(DOG CAT COW))
+
+Note that, since the call on NULL in the first line of LISTP returns T as its
+value, there is no need to put a T following (NULL OBJ).
+
+
+CONTINUE
+If you have created a long list of names, you may want to find out if someone
+is member of the list.  Using the comparator EQL you can compare the name you
+are looking for with each name on the list.  Tentatively, you might start your
+definition like this:
+
+	(DEFUN MBR (NAM LST)
+	  ((EQL NAM (FIRST LST)))
+	  ((EQL NAM (SECOND LST)))
+	  ((EQL NAM (THIRD LST)))
+	  ((EQL NAM (THIRD (CDR LST))))
+		    ...
+
+Not only is this getting messier by the line, but there is no end to it.
+After all, you had hoped to use your new function MBR on lists of arbitrary
+length.  So let's consider another approach.
+
+
+CONTINUE
+Given a name and a list, consider the following facts:
+
+1.  If the list is null (i.e. has no elements), the name is NOT a member of
+    the list.
+
+2.  If the name is EQL to the CAR of the list, the name is a member of the
+    list.
+
+3.  If the name is not EQL to the CAR of the list, the name is a member of
+    the list if and only if it is a member of the CDR of the list.
+
+It is absolutely essential that you fully understand and accept the above
+facts.  The first two facts should be fairly straight-forward.
+
+The third fact is slightly more subtle.  It means that if a name is not equal
+to the first element of a list, then to determine whether or not the name is a
+member of the list, all you have to do is determine whether or not the name is
+a member of the CDR of the list.
+
+
+CONTINUE
+Let's convert our three facts into a three step procedure for finding out if a
+name is a member of a list:
+
+1.  If the list is NULL, return NIL.
+2.  If the name is EQL to the CAR of the list, return T.
+3.  Otherwise, use this procedure to find out if the name is a member of the
+    CDR of the list and return the value the procedure returns.
+
+This is called a recursively defined procedure since step #3 tells us to use
+the very procedure we are defining to find out if the name is a member of the
+CDR of the list.  The procedure can be easily transformed into a recursive
+muLISP function definition as follows:
+
+$ (DEFUN MBR (NAM LST)
+    ((NULL LST) NIL)
+    ((EQL NAM (CAR LST)) T)
+    (MBR NAM (CDR LST)) )
+
+Use MBR to see if DOG is a member of (CAT COW DOG PIG).
+
+BREAK
+CLRSCRN
+In lesson #1 we mentioned that EQL was only good for comparing atoms, since
+NIL is returned if lists are compared.  For example:
+
+$ (EQL '(DOG CAT COW) '(DOG CAT COW))
+
+Using the techniques you learned from MBR, let's define a function called
+EQLIST that returns T if two lists of atoms are equal; otherwise EQLIST
+returns NIL.  Consider the following recursive procedure for EQLIST and
+convince yourself of its validity:
+
+1.  If NULL the first list, return NULL the second list.
+2.  If NULL the second list, return NIL.
+3.  If NOT EQL the CAR of the first list to the CAR of the second, return NIL.
+4.  Return EQLIST the CDR of the first list to the CDR of the second.
+
+During this break define EQLIST and try it out on some examples.  If you
+follow the above procedure, you will also need to define NOT, a predicate
+function that returns T if its single argument is NIL.
+
+BREAK
+Here is our definitions for EQLIST and NOT and an example:
+
+$ (DEFUN EQLIST (LST1 LST2)
+    ((NULL LST1) (NULL LST2))
+    ((NULL LST2) NIL)
+    ((NOT (EQL (CAR LST1) (CAR LST2))) NIL)
+    (EQLIST (CDR LST1) (CDR LST2)) )
+
+$ (DEFUN NOT (OBJ)
+    (EQL OBJ NIL) )
+
+$ (EQLIST '(DOG CAT COW) '(DOG CAT COW))
+
+Note that the definition of NOT is identical to the definition of NULL that we
+defined earlier.  This is because, as you will recall from lesson #1, muLISP
+uses the atom NIL to designate both the null list and the truth value false.
+
+CONTINUE
+So far the user-defined functions we have written have been either selector
+functions or predicates.  Let's try our hand at a constructor function.
+Specifically, a function for appending two lists together.
+
+CONS should immediately spring to mind as the prime candidate for building
+lists.  However, here is what happens if CONS is naively called with two lists
+as arguments:
+
+$ (CONS '(DAVE JOAN AL) '(KAREN ANN JOE))
+
+Instead of being a 6 element list, the result is a 4 element list whose first
+element is a 3 element list.  The result we wanted would have to be CONSed
+together as follows:
+
+$ (CONS 'DAVE (CONS 'JOAN (CONS 'AL '(KAREN ANN JOE))))
+
+Although multiple uses of CONS gives the desired result, what we want is a
+single function that returns the result when given two arbitrary length lists
+as arguments.
+
+CONTINUE
+Consider the problem of defining the function APPEND in terms of the 5
+primitive muLISP functions and the user-defined functions that will be defined
+by the time APPEND is called.  Remember APPEND itself qualifies as "a user-
+defined function that will be defined by the time APPEND is called" (in other
+words APPEND can be recursively defined).
+
+Begin by breaking the problem up into cases starting with the simplest case.
+Given the lists LST1 and LST2,
+
+1.  If LST1 null, return LST2.
+
+2.  Otherwise, CONS the CAR of LST1 onto the list you get by APPENDing the CDR
+    of LST1 onto LST2.
+
+The next screen defines APPEND and provides more justification for the above
+procedure.  However, if you feel ambitious, try defining APPEND during this
+break.
+
+BREAK
+CLRSCRN
+$ (DEFUN APPEND (LST1 LST2)
+    ((NULL LST1) LST2)
+    (CONS (CAR LST1) (APPEND (CDR LST1) LST2)) )
+
+$ (APPEND '(DAVE JOAN AL) '(KAREN ANN JOE))
+
+To understand this recursive definition, consider individually the two
+arguments to CONS in the last line of the definition.  The first argument,
+(CAR LST1), is simply the first element of LST1.  In the above example, the
+first argument to CONS is the atom DAVE.
+
+Assuming our APPEND is working correctly, the second argument to CONS,
+(APPEND (CDR LST1) LST2), is the list resulting from appending everything but
+the first element of LST1 to LST2.  Note that this is an acceptable use of
+recursion since each time APPEND calls itself it is with a shorter LST1 so
+eventually LST1 will be the null list and the recursion will halt.  In the
+above example, the second argument to CONS is the list
+(JOAN AL KAREN ANN JOE).
+
+CONTINUE
+Now its your turn to write some recursively defined constructor functions.
+Define the function REMBER (REMove memBER) that removes only the first
+occurrence of an atom from a list.  For instance, the call
+
+      (REMBER 'DOG '(CAT DOG COW DOG))
+
+should return the list (CAT COW DOG).  The definition should be of the
+following form:
+
+      (DEFUN REMBER (OBJ LST)
+	((NULL LST) ...)
+	((... OBJ ...) ...)
+	(CONS ... (REMBER ... ...)) )
+
+BREAK
+CLRSCRN
+REMBER can be defined as follows:
+
+$ (DEFUN REMBER (OBJ LST)
+    ((NULL LST) NIL)
+    ((EQL OBJ (CAR LST)) (CDR LST))
+    (CONS (CAR LST) (REMBER OBJ (CDR LST))) )
+
+$ (REMBER 'DOG '(CAR DOG COW DOG))
+
+If you had trouble with REMBER, you can redeem yourself by defining the
+function REMBER-ALL.  Instead of just the first occurrence,
+REMBER-ALL removes all occurrences of an atom from a list.  Thus
+
+       (REMBER-ALL 'DOG '(CAT DOG COW DOG))
+
+should return the list (CAT COW).  Hint: you need only make a small change to
+REMBER to get REMBER-ALL.
+
+BREAK
+CLRSCRN
+REMBER-ALL can be defined as follows:
+
+$ (DEFUN REMBER-ALL (OBJ LST)
+    ((NULL LST) NIL)
+    ((EQL OBJ (CAR LST))
+      (REMBER-ALL OBJ (CDR LST)) )
+    (CONS (CAR LST) (REMBER-ALL OBJ (CDR LST))) )
+
+$ (REMBER-ALL 'DOG '(CAR DOG COW DOG))
+
+Note the use of indentation in the above definition to highlight the flow of
+control within the definition.  Although we have not stated it explicitly, it
+should be clear that muLISP is a free format language (i.e. the spacing of the
+atoms in lists, including function definition lists, is not critical).  As you
+must have discovered by now, what is critical in muLISP is the proper
+balancing of parentheses!
+
+
+CONTINUE
+The last function we shall discuss in Lesson #2 is the constructor function
+REVERSE.  Its effect is simple enough:
+
+	  (REVERSE '(DOG CAT COW PIG))
+
+results in the list (PIG COW CAT DOG).  But REVERSE is tricky.
+
+During this break, see if you can define REVERSE.  If you can't figure it out,
+the next screen gives a hint without giving away the answer.
+
+BREAK
+Don't forget that in addition to the 5 primitives, you are free to use all the
+functions you have already defined including APPEND to write REVERSE.
+
+The next screen gives a more substantial hint.
+
+BREAK
+If you still haven't figured out how to write REVERSE, you may need to work on
+your RQ (Recursive Quotient)!  Using recursion, you can REVERSE the CDR of LST
+by the call
+
+		  (REVERSE (CDR LST))
+
+Then to REVERSE the whole LST, all that remains is to APPEND the REVERSE of
+the CDR of LST to the single element list
+
+		  (CONS (CAR LST) NIL)
+
+Give REVERSE one last try during this break.
+
+BREAK
+REVERSE can be defined as follows:
+
+$ (DEFUN REVERSE (LST)
+    ((NULL LST) NIL)
+    (APPEND (REVERSE (CDR LST)) (CONS (CAR LST) NIL)) )
+
+$ (REVERSE '(DOG CAT COW PIG))
+
+Although this is a logically acceptable definition of REVERSE, it is an
+extremely inefficient one.  This is because APPEND is called for each element
+of the list to be reversed.
+
+Let's take a whole new approach in our effort to define REVERSE more
+efficiently.  During this break, think about how you would reverse the order
+of a stack of sheets of paper.
+
+CONTINUE
+The simplest way to reverse a stack of paper is to repeatedly take the top
+sheet (i.e. the CAR) of the stack and put it on a second stack until the first
+stack is empty.  The second stack should start out empty.
+
+Given a list and a null list, this is the translation of the above process
+into a recursive procedure to REVERSE the first list:
+
+1.  If NULL the first list, return the second list.
+
+2.  Otherwise, CONS the CAR of the first list onto the second list and REVERSE
+    the CDR of the first list.
+
+Based on this procedure, you should now be able to define an efficient REVERSE
+during this break.
+
+BREAK
+REVERSE can be efficiently defined as follows:
+
+$ (DEFUN REVERSE (LST1 LST2)
+    ((NULL LST1) LST2)
+    (REVERSE (CDR LST1) (CONS (CAR LST1) LST2)) )
+
+$ (REVERSE '(DOG CAT COW PIG))
+
+Note that although REVERSE is defined with TWO formal arguments, it was called
+with only ONE actual argument.  In general, extra formal arguments are
+assigned the value NIL, which is often convenient.
+
+CONTINUE
+In this lesson you have learned how to extend pure muLISP by defining
+functions.  The following summarizes the major concepts presented in the
+lesson:
+
+1.  The parts of a definition including the function name, the formal argument
+    list, and the tasks comprising the function body.
+
+2.  Two types of tasks including simple tasks and conditional tasks.  Based on
+    the value returned by a predicate function, conditional tasks are used to
+    make decisions when functions are evaluated.
+
+3.  The power and elegance of recursive function definitions.  Recursive
+    function definitions are acceptable as long as the arguments in the
+    recursive call are closer to the termination condition.
+
+
+CONTINUE
+Congratulations on completing muLISP Lesson #2.  Although this concludes our
+discussion of pure muLISP, it by no means exhausts the potential number of
+functions that can be written in this subset of muLISP.  The following are few
+functions you might try defining:
+
+1.  (EQUAL list1 list2)  an equality comparator of <list1> and <list2>, but
+    unlike EQLIST, it works even if the elements of the lists are not atoms.
+    For example, on the list ((A B (C D)) (E F)).
+
+2.  (SUPER-REVERSE list)  reverses all levels of all lists in <list>.  For
+    example, ((A B (C D)) (E F)) goes to ((F E) ((D C) B A)).
+
+3.  (UNION set1 set2)  returns the set-theoretic union of <set1> and <set2>.
+    (Sets are lists in which no element occurs more than once).
+
+4.  (INTERSECTION set1 set2)  returns the intersection of two sets.
+
+5.  (SUBST new old list)  replaces all occurrences of <old> with <new> in
+    <list>.
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP3.LES b/Microsoft muLISP-86 v51/MULISP3.LES
new file mode 100644
index 0000000..a96a958
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP3.LES	
@@ -0,0 +1,518 @@
+File: MULISP3.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is muLISP lesson #3.  Estimated completion time is 50 minutes.
+
+The first two lessons taught the fundamentals of muLISP programming using
+pure muLISP.  Everything you learned about pure muLISP is of course true
+of full muLISP; however, there is much that was left unsaid.  With this
+lesson we shall commence describing the full capabilities of muLISP.
+
+In Lesson #3 we will examine each of the three primitive muLISP data objects
+in detail.  This lesson is primarily informative in nature and does not
+provide a lot in the way of interesting problems for you to solve.  However,
+it does provide an essential foundation for the later lessons.
+
+
+CONTINUE
+There are three types of primitive data objects in muLISP:  Symbols, Numbers,
+and Conses.
+
+muLISP provides numerous functions for recognizing, comparing, combining, and
+operating on these primitive data objects.  This allows you to construct
+complex data structures that can accurately model in the computer virtually
+any real world problem.  Therefore, we begin our discussion of muLISP with a
+description of the three basic data objects.
+
+As you may recall, pure muLISP has only two types of data objects: Atoms and
+Lists.  In full muLISP, atoms are further subdivided into Symbols and Numbers.
+In full muLISP, lists are only a subset of the more general structures called
+binary trees made up of Conses.
+
+
+CONTINUE
+The first type of data object we shall discuss is the symbol.  Associated with
+each muLISP symbol are 4 attributes:
+
+1.  Print name string:  A unique string of ASCII characters used by the system
+    to identify the symbol on input and to display the symbol on output.  A
+    symbol's print name string cannot be changed.
+
+2.  Current value:  A symbol's value can be any muLISP data object, including
+    itself.  The default value of a symbol is the symbol itself.
+
+3.  Property list:  The property list contains the symbol's property values
+    indexed on property keys.  See the muLISP lesson on property values for
+    more information about using properties.  The default property list of a
+    symbol is the null list.
+
+4.  Function definition:  A symbol's function definition is applied to the
+    arguments given when the symbol is called as a function.  The default
+    function definition invokes the "Undefined Function" error break.
+
+
+CONTINUE
+The recognizer function SYMBOLP returns T if its single argument is a symbol;
+otherwise it returns NIL.  For example:
+
+$ (SYMBOLP 'XYZ)
+
+$ (SYMBOLP 41)
+
+$ (SYMBOLP '(DOG CAT COW))
+
+During this break, see whether the null list, (), is a symbol or not.  To
+return to the lesson, type (RETURN) and press the <RETURN> key.
+
+BREAK
+CLRSCRN
+As discussed in an earlier lesson, the comparator function EQL is used to
+determine if two symbols are the same.  For example:
+
+$ (EQL 'APPLE (CAR '(APPLE ORANGE LEMON)))
+
+
+CONTINUE
+Since blank spaces, parentheses, and some other special characters have
+special significance to the muLISP, a quoted string must be used to create a
+symbol with such characters in its print name string.  Simply enclose the
+string containing such characters within double quotes to create such a
+symbol.  For example:
+
+$ "This is a (single) symbol!"
+
+Normally the double quotes around symbols containing special characters are
+NOT displayed when the symbol is output.  (Note: Double quote marks are
+automatically displayed around such symbols if the value of the control
+variable PRIN1 is NIL.)
+
+The empty string, entered as "", is also a symbol.  For example:
+
+$ (SYMBOLP "")
+
+CONTINUE
+The double quote mark itself can be included in a print name string by
+entering a backslash and a quote mark for each desired quote mark in the
+string.  For example:
+
+$ "She said, \"I am learning muLISP.\""
+
+When entering symbols using double quote marks, it is essential to balance the
+quote marks.  After entering a quote mark, muLISP will continue to think you
+are entering a single symbol until a matching quote mark is read.
+
+During this break, see what happens when you enter a symbol with an unmatched
+double quote mark and press the <RETURN> key.  To return to the lesson, you
+will need to balance the quote marks so you will get the dollar sign prompt.
+
+BREAK
+CLRSCRN
+A symbol can be assigned a value.  The value can be any muLISP data object
+including itself.  The default value of most muLISP symbols is the symbol
+itself.
+
+SET is the primitive function used to set the value of a symbol (SET's first
+argument) to a value (SET's second argument).  Of secondary importance is the
+fact that SET returns its second argument as its value.  For example:
+
+$ (SET 'FRUITS '(APPLES ORANGES LEMONS PEARS))
+
+$ FRUITS
+
+During this break, SET the symbol VOWELS to a list of the 5 vowels in the
+alphabet.
+
+BREAK
+CLRSCRN
+Generally the first argument to SET will be a quoted symbol.  Rather than
+having to explicitly quote the symbol, the function SETQ (SET Quote) can be
+used instead.  SETQ automatically quotes its first argument but NOT its
+second.  For example, rather than using SET to assign a list to 'VOWELS, you
+could use SETQ as follows:
+
+$ (SETQ VOWELS '(A E I O U))
+
+During this break, use SETQ to add the letter Y to VOWELS by CONSing it onto
+the current value of VOWELS.
+
+BREAK
+The following adds Y to the list of vowels:
+
+$ (SETQ VOWELS (CONS 'Y VOWELS))
+
+
+CONTINUE
+The second type of muLISP data object we shall discuss are Numbers.  Numbers
+are further subdivided into integers and ratios.  Integers are entered as a
+contiguous series of digits, optionally preceded by a minus sign.
+
+Since the value of a number is the number itself, there is no need to quote
+numbers:
+
+$ 41
+
+$ -75
+
+The comparator function EQL is used to test for the equality of two numbers:
+
+$ (EQL 3 4)
+
+$ (EQL 0 -0)
+
+
+CONTINUE
+Ratios can be entered using either decimal or slash notation (i.e. as two
+series of digits separated by a decimal point or a slash character, optionally
+preceded by a minus sign).  By default, ratios are displayed using decimal
+notation:
+
+$ 3/4
+
+$ -0.34
+
+$ (EQL 0.4 2/5)
+
+
+CONTINUE
+If the control variable *POINT* is NIL, muLISP displays ratios using slash
+notation instead of decimal notation.  Note that ratios are automatically
+reduced to lowest terms.  Also ratios having a denominator of one are
+automatically converted to integers.
+
+$ (SETQ *POINT* NIL)
+
+$ -5/7
+
+$ 0.33333333
+
+$ 12/9
+
+$ 5/1
+
+
+CONTINUE
+If the control variable *POINT* is zero or a positive integer, muLISP
+displays ratios using decimal notation to a maximum of POINT digits:
+
+$ (SETQ *POINT* 3)
+
+$ 2/3
+
+$ (SETQ *POINT* 7)
+
+$ 2/3
+
+
+CONTINUE
+The primitive recognizer function INTEGERP returns T if its argument is an
+integer; otherwise it returns NIL.  For example:
+
+$ (INTEGERP 100)
+
+$ (INTEGERP 'FIVE)
+
+$ (SETQ PRIMES '(2 3 5 7 11))
+
+$ (INTEGERP (CAR PRIMES))
+
+
+CONTINUE
+The primitive recognizer function NUMBERP returns T if its argument is a
+number (i.e. either an integer or ratio); otherwise it returns NIL.  For
+example:
+
+$ (NUMBERP 100)
+
+$ (NUMBERP 457.23)
+
+$ (NUMBERP -23/7)
+
+
+During this break, use NUMBERP and SYMBOLP to see if a sequence of digits
+enclosed in double quotes (e.g. "137") is a number or a symbol.
+
+BREAK
+The following two tests show that "137" is a symbol rather than a number:
+
+$ (NUMBERP "137")
+
+$ (SYMBOLP "137")
+
+
+CONTINUE
+Symbols and numbers are collectively called ATOMs to suggest their
+indivisibility by ordinary means.  The primitive recognizer function ATOM
+returns T if its argument is an atom (i.e. either a symbol or a number);
+otherwise is returns NIL.  For example:
+
+$ (ATOM 'APPLE)
+
+$ (ATOM 123)
+
+$ (ATOM '(DOG CAT COW))
+
+$ (ATOM '())
+
+
+CONTINUE
+Sometimes you may wish to refer to a symbol itself rather than its value.  In
+muLISP, the apostrophe character is used as a quote mark to suppress the
+evaluation of a symbol.  For example:
+
+$ (SETQ FOO 1492)
+
+$ FOO
+
+$ 'FOO
+
+Note that the apostrophe is different from the "back accent" or "accent grave"
+character, `, which also occurs on some terminals.
+
+During this break, use SETQ and the quote mark to set the value of FOO back to
+itself (i.e. make it be an auto-quoted symbol).
+
+BREAK
+The following restores the value of FOO to be itself:
+
+$ (SETQ FOO 'FOO)
+
+$ FOO
+
+
+CONTINUE
+The third primitive muLISP data object we shall discuss are Conses.  A cons
+is a nonatomic data object that points to two other data objects.  The name
+"cons" comes from the constructor function CONS discussed in the earlier
+lessons.
+
+Data can be stored in the computer's memory.  The location where a data item
+is stored is called its ADDRESS.  An address is analogous to a street address
+on a mailbox.  The data stored there is analogous to mail in the mailbox.  As
+with mailboxes, the contents of computer memory can change over time.
+
+Suppose we wish to represent the cons consisting of the symbol BILBO and his
+age 31.  We could store the symbol BILBO beginning at location 7, his age 31
+at location 2, and beginning at location 4 we could store a cons consisting
+of the pair of addresses 7 and 2:
+
+ Address:     1     2     3     4     5     6     7
+	   +-----+-----+-----+-----+-----+-----+-----+---
+Contents:  |     |  31 |     |  7  |  2  |     |BILBO|
+	   +-----+-----+-----+-----+-----+-----+-----+---
+
+CONTINUE
+muLISP manages the specific placement of data within memory automatically, so
+all we care about is the specific primitive symbols and numbers together with
+the way they are connected.  muLISP keeps track of addresses such as 7 and 2
+in our example, but for us they are a distraction.
+
+The following "box-car" representation of a cons suppresses such irrelevant
+detail:
+
+		    +-----+-----+
+		    |  .  |  .  |
+		    +-/---+---\-+
+		    /		\
+		  /		  \
+	       BILBO		  31
+
+
+CONTINUE
+If you have seen one box-car, you have seen them all.  So, to reduce clutter,
+I henceforth represent conses by a dot at the vertices in my diagrams.  For
+example:
+
+			       .
+			      / \
+			    /     \
+			 BILBO     31
+
+Since each cons has exactly two "branches", such diagrams are called binary
+trees.
+
+
+CONTINUE
+Although a linked collection of conses is best envisioned by humans as a
+binary tree structure, a linearized representation of conses is more suitable
+for a computer programming language.
+
+One of the linear representations recognized by muLISP is the so-called DOT
+notation.  In this notation, a cons is represented by a left parenthesis, a
+data item, a period, a data item, and a right parenthesis.  For example, the
+cons
+
+			       .
+			      / \
+			    /     \
+			 BILBO     31
+
+is represented in DOT notation as:
+
+			 (BILBO . 31)
+
+CONTINUE
+The left element of a cons is called the CAR of the cons.  The right element
+is called the CDR of the cons.  The elements of a cons can be any data object
+including another cons.  For example, BILBO's last name can be included in our
+binary tree as:
+
+			     .
+			    / \
+			  /     \
+			.	31
+		       / \
+		     /     \
+		  BILBO  BAGGINS
+
+The equivalent dot notation representation of this tree is:
+
+	      ((BILBO . BAGGINS) . 31)
+
+
+CONTINUE
+Let's add the fact that BILBO is a hobbit to our binary tree:
+
+			     .
+			    / \
+			  /     \
+			.      HOBBIT
+		       / \
+		     /     \
+		   .	   31
+		  / \
+		/     \
+	     BILBO  BAGGINS
+
+Before continuing think how this three cons binary tree would be represented
+using dot notation.
+
+CONTINUE
+The tree is represented in dot notation as:
+
+	 (((BILBO . BAGGINS) . 31) . HOBBIT)
+
+An alternative binary tree structure for this information is the one
+corresponding to:
+
+	 ((BILBO . BAGGINS) . (31 . HOBBIT))
+
+Sketch the corresponding binary tree diagram on a piece of paper, then hold it
+close to my face so I can check it out.
+
+			_____
+		       /     \
+		      >| O.O |<
+		       | \=/ |
+			\___/
+
+CONTINUE
+Oh well, my eyes must be getting bad.  It should have looked something like
+this:
+		       .
+		      / \
+		    /     \
+		  /	    \
+		.	     .
+	       / \	     / \
+	     /     \       /     \
+	  BILBO BAGGINS  31     HOBBIT
+
+
+From this discussion it should be clear that linked conses can be used to
+represent virtually any tree structured data.
+
+
+CONTINUE
+It is often most natural to represent a collection of conses as a LIST of data
+objects rather than as a deeply nested binary tree.  For example, the elements
+of a set are usually displayed as a list.
+
+muLISP represents a list as a linked collection of conses whose CAR cells
+point to the members of the lists and whose CDR cells point to the next cons.
+The linked list is terminated by a CDR cell that points to NIL.  For example:
+		  .
+		 / \
+	       /     \
+	   object1     .
+		      / \
+		    /     \
+		object2     .
+			      .
+				.
+			       / \
+			     /     \
+			 objectN   NIL
+
+CONTINUE
+When this binary tree is rotated 45 degrees counterclockwise, it is easier to
+see why it can be used to represent a list of data objects:
+
+     .--------.--- . . . ---.----- NIL
+     |	      |		    |
+     |	      |		    |
+  object1  object2       objectN
+
+The linear structure of lists suggests an external printed representation that
+is much more readable than the equivalent dot notation representation.  Thus
+muLISP will automatically display the above object using LIST notation:
+
+	 (object1 object2 ... objectN)
+
+rather than using dot notation:
+
+    (object1 . (object2 . ... (objectN . NIL) ...))
+
+CONTINUE
+The muLISP object display functions use list notation where possible and dot
+notation where necessary.  Thus, a structure of the form
+		 .
+		/ \
+	      /     \
+	 object1      .
+		     / \
+		   /     \
+	      object2      .
+			     .
+			       .
+			      / \
+			    /     \
+		       objectN    atom
+
+where <atom> is not the symbol NIL, is displayed in a mixed notation as:
+
+    (item1 item2  - - -  itemN . atom)
+
+
+CONTINUE
+The muLISP input reader function accepts list notation, dot notation, and
+mixed notation.  Moreover, any of the elements of a list can themselves be
+either lists or more general expressions.  The following examples show how
+muLISP displays a few expressions:
+
+$ '(DOG . (CAT . (COW . PIG)))
+
+$ '((AGE . 34) . (HOBBIES . (SWIMMING . THINKING)))
+
+
+CONTINUE
+During this lesson we have described the three primitive muLISP data objects:
+Symbols, Numbers, and Conses.  The following are the main points to remember:
+
+1.  Symbols:  Each symbol has an associated print name string, a value, a
+    property list, and a function definition.  Symbols containing special
+    characters can be entered using quoted strings.  SETQ is the function
+    most commonly used to assign a value to a symbol.
+
+2.  Numbers:  A number is a positive or negative rational number.  NUMBERP
+    is used to recognize numbers.  Numbers are subdivided into integers or
+    ratios.  INTEGERP is used to recognize integers.
+
+3.  Conses:  Conses are used to form binary tree structures that can be
+    represented using dot notation, list notation, or mixed notation.
+
+This concludes muLISP lesson #3.
+
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP4.LES b/Microsoft muLISP-86 v51/MULISP4.LES
new file mode 100644
index 0000000..ca52f88
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP4.LES	
@@ -0,0 +1,459 @@
+File:  MULISP4.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is muLISP programming lesson #4.  It requires about 50 minutes to
+complete.  In this lesson we shall discuss the following subjects:
+
+1.  Selector functions, used to select a component part of a binary tree
+    structured data object.
+
+2.  Constructor functions, used to construct binary trees from simpler data
+    objects.
+
+3.  Iterative versus applicative programming in muLISP.
+
+
+CONTINUE
+In our discussion of pure muLISP we described the most basic selector
+functions CAR and CDR in relation to lists.  The CAR of a list is the first
+element of the list.  The CDR of a list is everything but the first element
+of the list.  For example:
+
+$ (CAR '(MARS VENUS MERCURY))
+
+$ (CDR (CAR (CDR '((VOLUME 90) (DIMENSIONS 3 5 6) (WEIGHT 2000)))))
+
+Since lists are just a special way of thinking about binary trees, the
+functions CAR and CDR can also be used on such trees.
+
+
+CONTINUE
+As mentioned in the previous lesson, the left branch of a tree is called the
+CAR branch and the right the CDR branch.  Thus as you might expect, the
+functions CAR and CDR respectively extract the left and right branches of a
+binary tree.  Here are some examples of their use:
+
+$ (CAR '(GREEN . BLUE))
+
+$ (CDR '(GREEN . BLUE))
+
+$ (CAR (CDR '(YELLOW . (RED . BROWN))))
+
+During this break, extract the renewable energy sources from the binary tree
+assigned to the variable ENERGY:
+
+$ (SETQ ENERGY '((OIL . (COAL . SOLAR)) . (WOOD . NUCLEAR)))
+
+When you are ready to return to the lesson, type (RETURN) and press the
+<RETURN> key.
+
+BREAK
+CLRSCRN
+In addition to CAR and CDR, compositions of CAR and CDR are primitively
+defined in muLISP.  These functions are named using the middle letters of CAR
+and CDR to indicate the particular composition.  For example, the function
+CADR is equivalent to the CAR of the CDR of a list.  For example:
+
+$ (CAR (CDR '(DOG CAT COW)))
+
+$ (CADR '(DOG CAT COW))
+
+All other compositions of two, three, and four calls on CAR and CDR are also
+primitively defined in muLISP.  They are named CDAR, CAAR, CDDR, CAAAR, CAADR,
+CADAR, CDAAR, etc. in the obvious manner.  These functions are more efficient
+than using compositions of CAR and CDR and require less typing.
+
+During this break, redefine the functions SECOND and THIRD using the
+composition functions and try them out on some examples.
+
+BREAK
+Here is SECOND and THIRD defined using the composition functions:
+
+$ (DEFUN SECOND (LST)
+    (CADR LST) )
+
+$ (DEFUN THIRD (LST)
+    (CADDR LST) )
+
+$ (SECOND '(APPLE ORANGE LEMON PEAR))
+
+$ (THIRD '(APPLE ORANGE LEMON PEAR))
+
+
+CONTINUE
+Thus far we have always accessed a list beginning from the left end.
+Sometimes it may be necessary to access the last element of a list.
+
+During this break, recursively define the selector function LAST-ELEMENT that
+returns the last element of a list and test it out on some lists.
+
+BREAK
+This a recursive definition of LAST-ELEMENT.  Note that the case where LST
+is the null list must be handled as a special case:
+
+$ (DEFUN LAST-ELEMENT (LST)
+    ((NULL LST) NIL)
+    ((NULL (CDR LST))
+      (CAR LST) )
+    (LAST-ELEMENT (CDR LST)) )
+
+$ (LAST-ELEMENT '(THE QUICK BROWN FOX))
+
+
+CONTINUE
+Up to this point the lessons have taught the APPLICATIVE style of programming.
+This style emphasizes expression evaluation, functional composition, and
+recursion.
+
+muLISP also supports the ITERATIVE style of programming.  This style
+emphasizes iterative control constructs, variable assignments, and sequential
+processing.  The function LOOP is the primary muLISP iterative control
+construct.  LOOP takes any number of arguments, which are sequentially
+evaluated like the tasks of a function body, except:
+
+1.  After LOOP's last argument is evaluated, control returns back to the first
+    task in the loop.
+
+2.  When a nonNIL conditional task is evaluated in a loop, the value of the
+    conditional is returned as the value of the loop, and evaluation proceeds
+    with the task immediately following the loop, if any.
+
+There can be any number of conditional exits anywhere within a loop.  If there
+is no such exit, the loop will continue indefinitely.
+
+CONTINUE
+To illustrate the use of the LOOP control construct,  here is an alternative
+to the recursive definition of LAST-ELEMENT given earlier:
+
+$ (DEFUN LAST-ELEMENT (LST)
+    ((NULL LST) NIL)
+    (LOOP
+      ((NULL (CDR LST))
+	(CAR LST) )
+      (SETQ LST (CDR LST)) ) )
+
+$ (LAST-ELEMENT '(THE QUICK BROWN FOX))
+
+During this break, define MBR iteratively using LOOP.  (MBR atom list) returns
+T if <atom> is EQL to any element of <list>; otherwise it returns NIL.
+
+BREAK
+An iterative definition of MBR:
+
+$ (DEFUN MBR (ATM LST)
+    (LOOP
+      ((NULL LST) NIL)
+      ((EQL ATM (CAR LST)))
+      (SETQ LST (CDR LST)) ) )
+
+$ (MBR TED '(BOB CAROL TED ALICE))
+
+
+CONTINUE
+As you might suspect, muLISP has a primitively defined function, named LAST,
+for accessing the right end of a list.  However, unlike the function
+LAST-ELEMENT, LAST returns the last cons of a list rather than the last
+ELEMENT.  For example:
+
+$ (LAST '(TOKYO WASHINGTON LONDON PARIS))
+
+LAST-ELEMENT can be defined in terms of LAST as follows:
+
+$ (DEFUN LAST-ELEMENT (LST)
+    (CAR (LAST LST)) )
+
+$ (LAST-ELEMENT '(TOKYO WASHINGTON LONDON PARIS))
+
+During this break, guess what the LAST of the following data object is and
+verify your guess by a call on LAST:
+
+		(23 54 -23 15 . 27)
+
+BREAK
+CLRSCRN
+The primitive selector function NTH is useful for extracting the nth element
+of a list.  If <n> is a nonnegative integer, (NTH n list) returns the <n>th
+element of <list>.  muLISP uses ZERO BASED INDEXING to refer to the elements
+of a list.  Therefore, the first element (i.e. the car) of a list is referred
+to as the 0th element of the list.  For example:
+
+$ (NTH 0 '(BOOK PENCIL PAPER PEN))
+
+$ (NTH 2 '(BOOK PENCIL PAPER PEN))
+
+During this break, use NTH to define the function INDEXER such that if <list2>
+is a list of numbers, then (INDEXER list1 list2) returns a list of the
+elements of <list1> corresponding to the indices in <list2>.  Thus, the call
+
+		(INDEXER '(A B C D E F G) '(6 2 4 0))
+
+should return the list (G C E A).
+
+BREAK
+Here is our definition for INDEXER and an example:
+
+$ (DEFUN INDEXER (LST1 LST2)
+    ((NULL LST2) NIL)
+    (CONS (NTH (CAR LST2) LST1) (INDEXER LST1 (CDR LST2))) )
+
+$ (INDEXER '(A B C D E F G) '(6 2 4 0))
+
+
+CONTINUE
+Whereas NTH returns an element of a list, the primitive selector function
+NTHCDR returns a tail of a list.  If <n> is a nonnegative integer,
+(NTHCDR n list) returns the <n>th cdr of <list>.  For example:
+
+$ (NTHCDR 0 '(BOOK PENCIL PAPER PEN))
+
+$ (NTHCDR 2 '(BOOK PENCIL PAPER PEN))
+
+$ (NTHCDR 5 '(BOOK PENCIL PAPER PEN))
+
+
+Note that both NTH and NTHCDR return NIL if there are not enough elements
+in the list.
+
+CONTINUE
+Next we shall discuss the primitive muLISP constructor functions.
+
+In the pure muLISP lessons we described the constructor function CONS in terms
+of building lists.  CONS can also be described in terms of creating binary
+trees.  CONS creates a single cons, the CAR of which is the first argument to
+CONS and the CDR of which is the second argument.  For example:
+
+$ (CONS 'AGE 43)
+
+If you want some practice creating binary tree structures, during this break,
+CONS together the following binary tree:
+
+     (((IBM . PC) . (APPLE . MACINTOSH)) . (TANDY . TRS-80))
+
+BREAK
+The computer company tree:
+
+$ (CONS (CONS (CONS IBM PC) (CONS APPLE MACINTOSH)) (CONS TANDY TRS-80))
+
+As was explained in the previous lesson, binary trees are displayed using
+mixed DOT and LIST notation.
+
+
+CONTINUE
+Suppose we need to make a list of the values assigned to the variables
+FIRSTNAME, LASTNAME, and ADDRESS.  For example, if the variables were assigned
+the following values:
+
+$ (SETQ FIRSTNAME 'Jane)
+
+$ (SETQ LASTNAME 'Smith)
+
+$ (SETQ ADDRESS '(Honolulu Hawaii))
+
+we can construct the desired list by multiple uses of CONS:
+
+$ (CONS FIRSTNAME (CONS LASTNAME (CONS ADDRESS NIL)))
+
+
+CONTINUE
+Rather than having to call CONS for each variable, the primitive function LIST
+achieves this effect more conveniently.  LIST can have any number of
+arguments.  It returns a list of its arguments.  For example:
+
+$ (LIST FIRSTNAME LASTNAME ADDRESS)
+
+
+CONTINUE
+Although we defined the function APPEND in an earlier lesson, actually it is a
+primitively defined muLISP function.  APPEND's machine language definition is
+somewhat more flexible than the user-defined definition, in that the machine
+language version appends any number of lists together.  For example:
+
+$ (APPEND '(DOG CAT COW) '(SNAKE LIZARD CROCODILE) '(TROUT SALMON TUNA))
+
+
+CONTINUE
+The distinction between the three primitive constructor functions we have
+discussed thus far often leads to some confusion.  We can show the effect of
+the functions CONS, LIST, and APPEND by calling them with the same argument as
+follows:
+
+$ (CONS '(DOG CAT) '(COW PIG))
+
+$ (LIST '(DOG CAT) '(COW PIG))
+
+$ (APPEND '(DOG CAT) '(COW PIG))
+
+
+CONTINUE
+In the pure muLISP lessons, we defined REVERSE efficiently by using an
+ACCUMULATION variable.  The resulting definition was:
+
+$ (DEFUN REVERSE (LST1 LST2)
+    ((NULL LST1) LST2)
+    (REVERSE (CDR LST1) (CONS (CAR LST1) LST2)) )
+
+$ (REVERSE '(A B C D E))
+
+During this break, define REVERSE iteratively using the LOOP control
+construct.  You can use the same accumulation variable technique.
+
+BREAK
+An iterative definition of REVERSE:
+
+$ (DEFUN REVERSE (LST1 LST2)
+    (LOOP
+      ((NULL LST1) LST2)
+      (SETQ LST2 (CONS (CAR LST1) LST2))
+      (SETQ LST1 (CDR LST1)) ) )
+
+$ (REVERSE '(A B C D E))
+
+
+CONTINUE
+Often while sequentially processing the elements of a list in a loop, we refer
+to the CAR of the list, then shorten the list by one.  This operation is
+analogous to "popping" the first element off the top of a stack.
+
+The primitive muLISP function POP facilitates such operations.  If <stack> is
+a symbol whose value is a list, (POP stack) returns the CAR of the list and
+sets the value of <stack> to the CDR of the list.  For example, the last two
+tasks in the iterative definition of REVERSE,
+
+		(SETQ LST2 (CONS (CAR LST1) LST2))
+		(SETQ LST1 (CDR LST1))
+
+could be shortened using POP to the single task
+
+		(SETQ LST2 (CONS (POP LST1) LST2))
+
+
+CONTINUE
+Another operation commonly used while building a list within a loop is to CONS
+an object onto the front of a list by an assignment of the form
+
+		 (SETQ stack (CONS object stack))
+
+The primitive function PUSH can shorten such expressions to
+
+			(PUSH object stack)
+
+During this break, redefine REVERSE iteratively using PUSH and POP.
+
+BREAK
+Here is REVERSE defined using PUSH and POP:
+
+$ (DEFUN REVERSE (LST1 LST2)
+    (LOOP
+      ((NULL LST1) LST2)
+      (PUSH (POP LST1) LST2) ) )
+
+$ (REVERSE '(A B C D E))
+
+After having written at least four different versions of REVERSE, I hesitate
+to tell you that REVERSE is actually a primitively defined muLISP function!
+Naturally, the machine language version is the most efficient.
+
+
+CONTINUE
+When a function has completed execution and is ready to return a value, muLISP
+automatically restores the environment that existed at the time the function
+was called.  This means that you can change the value of the function's formal
+arguments without being concerned with saving the former values of the formal
+arguments.  For this reason, functions can be regarded as "black boxes" that
+have no effect on the environment other than their returned value.  If it
+should be necessary for a function to return more than a single value, it can
+create and return a list of the values.
+
+Another way a function can affect the outside environment is to make
+assignments within the function body to variables that are NOT included in its
+formal argument list.  Such variables are called "special", "fluid", or
+"global" variables.  The disadvantage is that it is easy to overlook such
+hidden communication channels when making program changes, thus making it easy
+to introduce bugs.
+
+
+CONTINUE
+Both the recursive and iterative definitions of REVERSE take time proportional
+to the length of their argument.  But for long lists, the iterative version is
+perhaps 20 percent faster, depending upon the computer and amount of memory
+available.  However, the recursive version is more compact.  When there is
+such a trade-off between speed and compactness, a good strategy is to program
+for speed in the most heavily used functions, and program for compactness
+elsewhere.
+
+Another consideration when choosing between iteration and recursion is the
+amount of storage required to perform a given task.  Each time a function is
+called, addresses of the return point and the former values of the formal
+arguments must be stored on a STACK so that the former environment can be
+restored when the function returns.
+
+Since recursion involves repeated nesting of function calls, a recursive
+function can exhaust all available memory before completing its task.  This
+would invoke the "Memory Space Exhausted" error trap.  The use of iteration in
+such situations might permit the computation to proceed to completion.
+
+
+CONTINUE
+muLISP has three primitive logical functions designed to combine truth values
+returned by predicate functions.  The function OR takes any number of
+arguments and evaluates them from left to right until a nonNIL value is
+encountered or no arguments are left.  If a nonNIL argument is found, OR
+returns that argument's value; otherwise, OR returns NIL.
+
+You can rely on the fact that subsequent arguments of OR will not be evaluated
+after a nonNIL value is encountered.  A nonNIL value does not have to be T, so
+the returned value isn't restricted to T or NIL.  For program control
+purposes, muLISP treats any nonNIL value as T, which is a great programming
+convenience.
+
+Remember that a muLISP atom is either a symbol OR a number.  Thus, the
+recognizer function could be defined as:
+
+$ (DEFUN ATOM (U)
+    (OR (SYMBOLP U) (NUMBERP U)) )
+
+
+CONTINUE
+Analogous to OR, there is a built-in AND function that takes any number of
+arguments.  AND evaluates its successive arguments until a NIL value is
+encountered or no arguments are left.  AND returns the value of the last
+argument that was evaluated.  Thus you can rely on the fact that subsequent
+arguments will not be evaluated after a NIL value is encountered.  For
+example:
+
+$ (AND (SYMBOLP 'frog) (NUMBERP 7))
+
+CONTINUE
+The primitive function NOT returns T if its argument is NIL; otherwise, it
+returns NIL.  For example:
+
+$ (NOT (ATOM '(SODIUM . CHLORIDE)))
+
+As we mentioned earlier, the definition of NOT is identical to NULL.  NULL
+should be used when testing for empty lists.  NOT should be used when testing
+the truth value returned by predicate functions.
+
+
+CONTINUE
+The following points summarize what we have learned in this lesson:
+
+1.  The use of the 28 primitively defined compositions of CAR and CDR (CADR,
+    CDDR, CAAAR, etc.) for extracting the components of binary trees.
+
+2.  The use of the functions NTH and NTHCDR to index into a list.
+
+3.  The use and distinction between the three primitive constructor functions
+    CONS, LIST, and APPEND.
+
+4.  Iterative programming using the LOOP control construct and the PUSH and
+    POP "stack" functions.
+
+5.  The logical functions AND, OR, and NOT that are used to logically combine
+    the truth values returned by predicate functions.
+
+This concludes muLISP lesson #4.
+
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP5.LES b/Microsoft muLISP-86 v51/MULISP5.LES
new file mode 100644
index 0000000..80be2df
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP5.LES	
@@ -0,0 +1,391 @@
+File:  MULISP5.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is muLISP programming lesson #5.  This lesson introduces the primitive
+muLISP numerical functions and presents several techniques useful for writing
+efficient mathematical functions.
+
+muLISP provides the user with both infinite precision integer arithmetic and
+adjustable precision rational arithmetic.  This means that the only limit on
+the size of integers is available computer memory.  Integers consisting of
+thousands of digits are possible.  This makes muLISP useful for investigations
+in the fields of number theory and cryptography.
+
+By default the precision muLISP uses for rational arithmetic provides about
+7 digits of accuracy.  This approximates the accuracy of single precision
+floating point arithmetic.  The description of the function PRECISION in
+Chapter 5 of the muLISP Reference Manual provides details on how to increase
+the precision used for rational arithmetic.
+
+
+CONTINUE
+We begin by discussing the primitive numerical functions muLISP provides.
+The functions +, -, *, and / denote addition, subtraction, multiplication,
+and division respectively.  In most conventional programming languages, you
+enter numerical expressions using infix notation (i.e. operators appear
+between their operands).  For example:
+
+			3*4 + 5
+
+Since LISP is a functional programming language, functional notation is more
+natural and consistent for numerical expressions.  For example, the above
+expression is entered as:
+
+$ (+ (* 3 4) 5)
+
+During this break, familiarize yourself with these four numerical functions.
+When ready to return to the lesson, type (RETURN) and press the <RETURN> key.
+
+BREAK
+CLRSCRN
+One advantage of functional notation over operator notation is that you are
+not limited to two operands for each operation.  The functions +, *, -,
+and / can accept a variable number of arguments.  For example:
+
+$ (+ 45 -23 57)
+
+$ (* 1 2 3 4 5)
+
+During this break using test cases, empirically determine what the functions
+- and / do when called with more than two arguments.
+
+BREAK
+CLRSCRN
+If a numerical function is inadvertently called with nonnumeric arguments, the
+"Nonnumeric Argument" error message will be displayed on the console followed
+by the errant function call and the option prompt
+
+	Abort, Break, Continue, Top-level, Restart, System?
+
+You then must select one of the five options by entering its first letter.
+The description of the function BREAK in Chapter 5 of the muLISP Reference
+Manual describes the options in detail.  The next screen summarizes the
+options available.
+
+CONTINUE
+Summary of the error break options:
+
+Abort:  aborts execution, returns control directly to the current level
+    of the read-eval-print loop, and prompts the user for further input.
+
+Break:  temporarily suspends execution and prompts the user for input.  The
+    errant function can be determined by examining the value of the variable
+    BREAK.  To return from the break, type (RETURN expn) where <expn> is the
+    value you want to be returned as the value of the errant function call.
+
+Continue:  continues execution with the errant function call used as the value
+    returned.
+
+Top-level:  aborts execution, returns control to the top-level read-eval-
+    print loop, and prompts the user for further input.
+
+Restart:  abandons the current muLISP environment and starts up a fresh muLISP
+    system.
+
+System:  terminates muLISP and returns to the host operating system.
+
+
+CONTINUE
+Enough of errors, let's return to mathematics!  The factorial of a number is
+of great importance in probability theory.  The factorial of a nonnegative
+integer N, denoted N!, can be recursively defined as follows:
+
+		0! = 1,
+		N! = N*(N-1)! if N > 0
+
+The equivalent muLISP definition of FACTORIAL is:
+
+$ (DEFUN FACTORIAL (N)
+    ((EQL N 0) 1)
+    (* N (FACTORIAL (- N 1))) )
+
+$ (FACTORIAL 5)
+
+This is an efficient definition; however, if N is large there is the
+possibility of a memory space exhausted error because of a stack-overflow.
+During this break, write and test an iterative version of FACTORIAL.  Hint:
+you will need an accumulation variable for the result.
+
+BREAK
+An iterative definition for FACTORIAL and an example:
+
+$ (DEFUN FACTORIAL (N
+      % Local: % RSLT)
+    (SETQ RSLT 1)
+    (LOOP
+      ((ZEROP N) RSLT)
+      (SETQ RSLT (* N RSLT))
+      (SETQ N (- N 1)) ) )
+
+$ (FACTORIAL 100)
+
+As the example illustrates, muLISP can handle very large numbers.  In the
+definition we introduced the primitive recognizer function ZEROP.  (ZEROP N)
+is equivalent to (EQL N 0) but is slightly more efficient.
+
+CONTINUE
+A series that keeps turning up in nature in the strangest places is the
+Fibonacci Series.  The Nth Fibonacci number, denoted F(N), can be recursively
+defined as follows:
+
+		F(0) = 1,
+		F(1) = 1,
+		F(N) = F(N-1) + F(N-2)  if  N > 1.
+
+The equivalent muLISP definition of FIBONACCI is:
+
+$ (DEFUN FIBONACCI (N)
+    ((ZEROP N) 1)
+    ((EQL N 1) 1)
+    (+ (FIBONACCI (- N 1)) (FIBONACCI (- N 2))) )
+
+$ (FIBONACCI 10)
+
+During this break, gain a feel for the efficiency of the above algorithm by
+calling FIBONACCI with progressively larger arguments.
+
+BREAK
+CLRSCRN
+As you test cases should have demonstrated, this is an extremely inefficient
+algorithm.  The problem is that to compute the Nth Fibonacci number, the
+(N-2)th Fibonacci number is unnecessarily computed twice, the (N-3)th three
+times, the (N-4)th five times, and it keeps gets getting worse.
+
+Since this is a recursive algorithm, most people jump to the conclusion that
+recursion is the problem, and set about writing a messy iterative definition
+to achieve efficiency.  But the problem is not recursion but the algorithm.
+
+Rather than computing the Nth Fibonacci number by working backward toward
+zero, the efficient way is to start at zero and work up to the Nth Fibonacci
+number using two variables to store the two most recently computed Fibonacci
+numbers.
+
+During this break, use this approach to define an efficient, yet recursive,
+definition for Fibonacci numbers calling it FIB.  Compare the efficiency of
+FIB with FIBONACCI.
+
+BREAK
+An efficient, recursive definition for Fibonacci numbers:
+
+$ (DEFUN FIB (N F1 F2)
+    ((ZEROP N) F1)
+    (FIB (- N 1) (+ F1 F2) F1) )
+
+$ (FIB 10 1 0)
+
+$ (FIBONACCI 10)
+
+FIB is a function of 3 arguments.  The first argument is N, the second must be
+1, and the third 0.  If you insist on a single argument Fibonacci function,
+you can define a "front-end" function that merely calls FIB with the
+appropriate second and third arguments.
+
+For those of you still not convinced of the elegance and efficiency of
+recursion, write an iterative definition for Fibonacci numbers and compare it
+to the above definition.  If you are a believer, you can simply continue on.
+
+CONTINUE
+Raising an expression to an integer power is certainly an important
+mathematical operation.  To raise N to Mth power all you have to do is
+multiply N times itself M times.
+
+During this break, write an iterative definition of POWER as a function of two
+arguments.
+
+BREAK
+A iterative definition of POWER:
+
+$ (DEFUN POWER (N M
+      % Local: % RSLT )
+    (SETQ RSLT 1)
+    (LOOP
+      ((ZEROP M) RSLT)
+      (SETQ RSLT (* N RSLT))
+      (SETQ M (SUB1 M)) ) )
+
+$ (POWER 2 10)
+
+The call to the primitive function SUB1 in the above definition is equivalent
+to, but slightly more efficient, than the call (- N 1) would be.  ADD1 is also
+a primitively defined muLISP function.
+
+There is an even more efficient way of computing powers of numbers than this
+iterative technique.  On to the next screen!
+
+
+CONTINUE
+Consider the following facts:
+
+1.  If M is an even number, then N to Mth power is equal to N squared raised
+    to the M/2th power.
+
+2.  If M is odd, then N to Mth power is N times N raised to the (M-1)th power.
+
+To implement this algorithm you will need the primitive recognizer function
+EVENP.  It returns T if and only if its argument is an even integer; otherwise
+it returns NIL.
+
+During this break, define POWER using the recursive squaring approach
+described above.
+
+BREAK
+An efficient, recursive definition of POWER:
+
+$ (DEFUN POWER (N M)
+    ((ZEROP M) 1)
+    ((EVENP M)
+      (POWER (* N N) (/ M 2)) )
+    (* N (POWER N (SUB1 M))) )
+
+$ (POWER 10 100)
+
+CONTINUE
+The primitive function TRUNCATE is useful for converting ratios and quotients
+to integers.  If <n> is a number, (TRUNCATE n) truncates <n> to the nearest
+integer in the direction of zero:
+
+$ (TRUNCATE 7/3)
+
+$ (TRUNCATE -0.95)
+
+
+If called with two arguments, TRUNCATE returns their truncated integer
+quotient.  Note that (TRUNCATE n m) is equivalent to (TRUNCATE (/ n m)):
+
+$ (TRUNCATE 7 3)
+
+$ (TRUNCATE -46.3 5.2)
+
+
+CONTINUE
+TRUNCATE returns the truncated integer quotient of its two arguments.  The
+primitive function REM returns the corresponding remainder of its two
+arguments.  TRUNCATE and REM are defined so they observe the law between
+quotients and remainders:  If (TRUNCATE n m) returns the integer q and
+(REM n m) returns the number r, then
+
+			n = q*m + r
+
+Often it is useful to obtain both the quotient and remainder at the cost
+of only one division.  The primitive function DIVIDE returns cons of the
+quotient and remainder of its two arguments.
+
+$ (TRUNCATE 7 3)
+
+$ (REM 7 3)
+
+$ (DIVIDE 7 3)
+
+
+CONTINUE
+The Greatest Common Divisor (GCD) of two integers is the largest nonnegative
+integer number that evenly divides both integers.  Euclid's algorithm for the
+GCD of the integers N and M can be paraphrased as:
+
+1.  If N = 0, then GCD (N, M) = M;
+
+2.  Otherwise, GCD (N, M) = GCD (M mod N, N).
+
+During this break, define the function GCD using Euclid's algorithm and try it
+out on some examples.  Use the function REM to obtain M mod N.
+
+BREAK
+Recursive definition of GCD using Euclid's algorithm:
+
+$ (DEFUN GCD (N M)
+    ((ZEROP N) M)
+    (GCD (REM M N) N) )
+
+$ (GCD 21 56)
+
+Actually the functions GCD and LCM (Least Common Multiple) are primitively
+defined in muLISP.  Naturally the primitive versions are faster and can accept
+an arbitrary number of arguments.
+
+
+CONTINUE
+Finally we need to mention the primitive numerical comparator functions:  =,
+/=, <, >, <=, and >=.  For example:
+
+$ (= 34 34.0)				;Equal test
+
+$ (/= 3/4 0.75)				;Not equal test
+
+$ (< 67 45)				;Less than test
+
+$ (>= 19 17 17)				;Greater than or equal test
+
+As the last example shows, the numerical comparator functions can be called
+with more than two arguments.  If called with nonnumeric arguments, these
+functions will cause a "Nonnumeric Argument" error break.
+
+
+CONTINUE
+To determine if a number lies within a given interval, the function < can be
+called with 3 arguments.  For example, to determine if "g" is a lower case
+letter enter:
+
+$ (< 96 (ASCII 'g) 123)
+
+The function ASCII returns the ASCII code if given a character name.  It
+returns the equivalent ASCII character if given a number between 0 and 256.
+
+During this break, write the recognizer function LOWERCASE that determines if
+a character is a lower case character.
+
+BREAK
+The LOWERCASE recognizer function:
+
+$ (DEFUN LOWERCASE (CHAR)
+    (< 96 (ASCII CHAR) 123) )
+
+$ (LOWERCASE 'g)
+
+CONTINUE
+Let's finish off this lesson by writing a function for sorting a list of
+numbers into increasing order.  We are not too concerned with efficiency so
+let's use a simple "insertion sort" algorithm that is adequate for short
+lists.
+
+First we need a function that inserts an number in the proper place in a
+sorted list of numbers.  During this break, write INSERT-NUM, a function that
+inserts NUM into LST.  Use iteration or recursion depending on your taste.
+
+BREAK
+A recursively defined INSERT-NUM function:
+
+$ (DEFUN INSERT-NUM (NUM LST)
+    ((NULL LST)
+      (LIST NUM) )
+    ((< NUM (CAR LST))
+      (CONS NUM LST) )
+    (CONS (CAR LST) (INSERT-NUM NUM (CDR LST))) )
+
+$ (INSERT-NUM 12 '(5 9 11 14 19 21))
+
+During this break, use INSERT-NUM to write the function NUMBER-SORT that sorts
+a list of numbers.
+
+BREAK
+A recursive defined NUMBER-SORT function:
+
+$ (DEFUN NUMBER-SORT (LST)
+    ((NULL LST) NIL)
+    (INSERT-NUM (CAR LST) (NUMBER-SORT (CDR LST))) )
+
+$ (NUMBER-SORT '(34 23 -14 27 56 22 83))
+
+
+The built-in function SORT uses an efficient list merge sort.  If <test> is
+a comparator function, (SORT list test) sorts and returns <list> based on
+<test>.  For example:
+
+$ (SORT '(34 23 -14 27 56 22 83) '<)
+
+
+This concludes our discussion of numerical programming techniques using
+muLISP.  Congratulations on successfully completing lesson #5.
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP6.LES b/Microsoft muLISP-86 v51/MULISP6.LES
new file mode 100644
index 0000000..4bdc4af
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP6.LES	
@@ -0,0 +1,620 @@
+File:  MULISP6.LES  (c)		12/27/85	Soft Warehouse, Inc.
+
+CLRSCRN
+This is muLISP programming lesson #6.  In this lesson we will provide muLISP
+with both line-drawing and "turtle" graphics capabilities.
+
+First we will define a function for plotting points on the computer screen.
+Next we will write a routine for drawing straight lines across the screen.
+Finally, we will use a polynomial approximation to define functions for
+finding the sine and cosine of an angle.  Once these steps have been
+accomplished, it is relatively easy to implement turtle graphics.
+
+The LOGO computer language has popularized the idea of using turtle graphics
+to teach children to program.  LOGO was first implemented in LISP and it
+remains a close cousin.  Turtle graphics is based on the idea of a "turtle"
+that has a heading and a position on the graphics screen.  Figures are drawn
+by issuing commands to the turtle, which draws a line as it moves around the
+screen.
+
+
+CONTINUE
+muLISP is available for a variety of computers and terminals, many of which do
+not support high resolution graphics.  The systems that do support graphics
+have widely varying graphics protocols.  Consequently, to make this lesson
+applicable to the greatest possible number of systems, the lesson begins by
+implementing "character graphics" using only ASCII characters positioned using
+the cursor addressing function (SET-CURSOR row column).
+
+If you are running on a computer type that supports cursor positioning, the
+definition for the function SET-CURSOR is built-in.  Otherwise, you must
+either define your own SET-CURSOR function.  If SET-CURSOR is working
+correctly, the command
+
+		(SET-CURSOR 0 0)
+
+will position the cursor at the upper left corner of the screen.  During this
+break, make sure that SET-CURSOR is working correctly.
+
+BREAK
+CLRSCRN
+We will assign the global variable ROWS to be the number of rows of characters
+on the computer screen.  COLUMNS is the number of columns.  Thus the command
+
+	       (SET-CURSOR (SUB1 ROWS) (SUB1 COLUMNS))
+
+should position the cursor at the lower right corner of the screen.  If the
+following assignments are inappropriate for your computer screen, correct them
+during this break:
+
+$ (SETQ COLUMNS 80)
+
+$ (SETQ ROWS 24)
+
+BREAK
+CLRSCRN
+Rather than using rows and columns, the position of a point on a graphics
+screen is specified by giving it X and Y coordinates relative to an origin.
+The X-coordinate of a point is the horizontal distance from the origin to the
+point; it is positive if the point is to the right of the origin, negative if
+to the left.  The Y-coordinate of a point is the vertical distance from the
+origin to the point; it is positive if the point is above the origin, negative
+if below.
+
+			Y
+			|
+			|
+		  ------+------  X
+			|
+			|
+
+Coordinates are normally written as a pair of numbers between square brackets;
+the first is the X-coordinate, the second is the Y-coordinate.  For example
+the origin of the coordinate system is the point at [0 0].  Generally, the
+center of the screen is chosen as the origin for graphics routines.
+
+
+CONTINUE
+SET-CURSOR uses the upper left corner of the screen as its origin and it
+is called with coordinates in the opposite order to that used in a graphics
+coordinate system.  Thus we define the function DOT that plots a character
+at a specified coordinate on the screen:
+
+$ (DEFUN DOT (X-COORD Y-COORD
+      LINELENGTH )
+    ((AND (< (- X-MAX) X-COORD X-MAX)
+	  (< (- Y-MAX) Y-COORD Y-MAX) )
+      (SET-CURSOR (- Y-MAX Y-COORD) (+ X-MAX X-COORD))
+      (PRIN1 DOT) ) )
+
+$ (SETQ X-MAX (TRUNCATE (ADD1 COLUMNS) 2))
+
+$ (SETQ Y-MAX (TRUNCATE (ADD1 ROWS) 2))
+
+LINELENGTH is included in DOT's formal argument list to temporarily set this
+control variable to NIL, thus defeating muLISP's automatic line termination
+feature while plotting points.
+
+CONTINUE
+The character that is displayed when plotting a point is determined by the
+value of the control variable DOT.
+
+$ (SETQ DOT '*)
+
+Computers that have extended the ASCII character set may have a more
+appropriate character to use for plotting points.  For example, (ASCII 2) is
+a "smiley" circle on the IBM PC.  During this break you can reassign DOT, if
+you so desire.
+
+BREAK
+CLRSCRN
+The function DRAW is a convenient means of clearing the screen,
+performing several graphics operations, and then returning the cursor
+to the top left corner of the screen:
+
+$ (DEFUN DRAW (NLAMBDA COMMANDS
+    (CLEAR-SCREEN)
+    (MAPC 'EVAL COMMANDS)
+    (SET-CURSOR 0 0) ))
+
+During this break, test out DOT by issuing the command
+
+	 (DRAW (DOT 15 8) (DOT 15 -8) (DOT -15 -8) (DOT -15 8))
+
+BREAK
+CLRSCRN
+Now that we can plot points, the next step is to implement a line-drawing
+routine.  But first we must introduce a couple of primitively defined,
+numerical functions that are required by the line-drawing algorithm.
+
+The function ABS returns the absolute value of its argument:
+
+$ (ABS 24.3)
+
+$ (ABS -16)
+
+$ (ABS 0)
+
+
+CONTINUE
+The function SIGNUM returns 1 if its argument is positive, -1 if its argument
+is negative, and 0 if its argument is zero:
+
+$ (SIGNUM -7)
+
+$ (SIGNUM 5.3)
+
+$ (SIGNUM 0.0)
+
+
+CONTINUE
+Bresenham's algorithm is a particularly fast line-drawing algorithm because it
+involves only addition and subtraction.  It is described in books on graphics
+such as "Principles of Computer Graphics" by William M. Newman and Robert F.
+Sproull (McGraw-Hill Book Company, 1979).  We will use it to define the
+function LINE that draws a line from [x1 y1] to [x2 y2].
+
+
+CONTINUE
+If a line segment has a gradual slope (i.e. less than 45 degrees), the line-
+drawing routine must plot several adjacent points with the same Y-coordinate.
+Thus, for lines with a gentle slope, Bresenham's algorithm plots points as a
+function of the X-coordinate.  On the other hand, if a line is steep, adjacent
+points are plotted as a function of the Y-coordinate.  LINE calls STEEP-SLOPE
+or GENTLE-SLOPE depending on the steepness of the line being drawn:
+
+$ (DEFUN LINE (X1 Y1 X2 Y2
+      DELTA-X DELTA-Y SIGN-DELTA-X SIGN-DELTA-Y)
+    (SETQ DELTA-X (- X2 X1)
+	  DELTA-Y (- Y2 Y1)
+	  SIGN-DELTA-X (SIGNUM DELTA-X)
+	  SIGN-DELTA-Y (SIGNUM DELTA-Y)
+	  DELTA-X (ABS DELTA-X)
+	  DELTA-Y (ABS DELTA-Y))
+    ((< DELTA-Y DELTA-X)
+      (GENTLE-SLOPE) )
+    (STEEP-SLOPE) )
+
+
+CONTINUE
+The gradual slope line-drawing function:
+
+$ (DEFUN GENTLE-SLOPE ()
+    (SETQ DELTA-Y (* 2 DELTA-Y)
+	  Y2 (- DELTA-Y DELTA-X)
+	  DELTA-X (- DELTA-X Y2))
+    (LOOP
+      (DOT X1 Y1)
+      ((EQ X1 X2))
+      ( ((PLUSP Y2)
+	  (INCQ Y1 SIGN-DELTA-Y)
+	  (DECQ Y2 DELTA-X) )
+	(INCQ Y2 DELTA-Y) )
+      (INCQ X1 SIGN-DELTA-X) ) )
+
+Note the use of the special forms INCQ (INCrement Quote) and DECQ (DECrement
+Quote) in the definition of GENTLE-SLOPE.  If <variable> is a symbol and <n>
+is a number, (INCQ variable n) adds <n> to the value of <variable>.  It is
+equivalent to (SETQ variable (+ variable n)), but is more efficient.  If INCQ
+is called without a second argument, <variable> is incremented by one.  DECQ
+is analogous to INCQ except it subtracts from its first argument.
+
+CONTINUE
+The steep slope line-drawing function:
+
+$ (DEFUN STEEP-SLOPE ()
+    (SETQ DELTA-X (* 2 DELTA-X)
+	  X2 (- DELTA-X DELTA-Y)
+	  DELTA-Y (- DELTA-Y X2))
+    (LOOP
+      (DOT X1 Y1)
+      ((EQ Y1 Y2))
+      ( ((PLUSP X2)
+	  (INCQ X1 SIGN-DELTA-X)
+	  (DECQ X2 DELTA-Y) )
+	(INCQ X2 DELTA-X) )
+      (INCQ Y1 SIGN-DELTA-Y) ) )
+
+The line-drawing function LINE is now complete.  For example, the command
+
+      (DRAW (LINE -20 -5 0 10) (LINE 0 10 20 -5) (LINE 20 -5 -20 -5))
+
+should draw a triangle on the screen.  During this break, try drawing a box
+using LINE.
+
+BREAK
+CLRSCRN
+Rather than using an absolute coordinate system to draw figures, turtle
+graphics uses polar coordinates (i.e. line segments are specified by giving a
+distance and an angle from a starting point).  To use our LINE function we
+must convert from polar to absolute coordinates.  Thus we need to define
+functions for finding the sine and cosine of an angle.
+
+No matter how accurately the sine (or cosine) is computed, when multiplied by
+the length of a line segment and the result rounded to the nearest integer,
+the resulting coordinate can differ by one from what it would be if an exact
+sine (or cosine) were used.  Using least-squares polynomials, we can compute
+sufficiently accurate rational approximations for the sine and cosine of an
+angle to insure that the error never exceeds one "pixel" (i.e. a graphics
+point).  In fact, an error of one pixel is relatively unlikely for even the
+longest line segment that will fit on our screen.
+
+It is always possible to reduce sines and cosines to equivalent ones in the
+range 0 through 45 degrees.  Hence we begin by defining sine and cosine
+functions restricted to that range.
+
+CONTINUE
+Throughout the 0 through 45 degree range, a least-squares fitted quintic
+polynomial differs from sine by less than 1 part per 3000, while  a least-
+squares fitted quartic polynomial differs from cosine by less than 1 part per
+2000.  The diagonal of an 80 by 24 screen is less than 84 units, so if the
+maximum truncation error occurred at this particular bearing and if we move a
+distance equal to the entire diagonal, there would be about 84 chances out of
+2000 for an error of one pixel.
+
+$ (DEFUN REDUCED-SIN (DEG)
+    (/ (* DEG (+ 1324959969 (* (SETQ DEG (* DEG DEG)) (+ -67245 DEG))))
+       75914915920) )
+
+$ (DEFUN REDUCED-COS (DEG)
+    (SETQ DEG (* DEG DEG))
+    (/ (+ 266153374 (* DEG (+ -40518 DEG)))
+       266153374) )
+
+$ (REDUCED-SIN 45)
+
+$ (REDUCED-COS 45)
+
+CONTINUE
+Now for the somewhat tricky angle reduction functions:
+
+$ (DEFUN SIN (ANGLE)
+    ((MINUSP ANGLE) (- (SIN (- ANGLE))))
+    (SETQ ANGLE (DIVIDE (REM ANGLE 360) 45))
+    (SIN-COS (CAR ANGLE) (CDR ANGLE)) )
+
+$ (DEFUN COS (ANGLE)
+    (SETQ ANGLE (DIVIDE (REM (ABS ANGLE) 360) 45))
+    (SIN-COS (+ 2 (CAR ANGLE)) (CDR ANGLE)) )
+
+$ (DEFUN SIN-COS (N45DEG RESID)
+    ((> N45DEG 3)
+      (- (SIN-COS (- N45DEG 4) RESID)) )
+    ((ZEROP N45DEG) (REDUCED-SIN RESID))
+    ((EQL N45DEG 1) (REDUCED-COS (- 45 RESID)))
+    ((EQL N45DEG 2) (REDUCED-COS RESID))
+    (REDUCED-SIN (- 45 RESID)) )
+
+$ (SIN -390)
+
+CONTINUE
+Now that we have a line-drawing routine and functions for finding the sine and
+cosine of an angle, we are ready to start implementing turtle graphics.
+
+The current position of the turtle on the screen is stored by the integer
+global variables X-POS and Y-POS.  Rather than using SETQ directly to assign
+values to X-POS and Y-POS, you can use the SETPOS command, defined as follows:
+
+$ (DEFUN SETPOS (X Y)
+    (SETQ X-POS X  Y-POS Y) )
+
+
+CONTINUE
+In turtle graphics, the turtle always has a heading.  The heading is measured
+in degrees measured clockwise from a line pointing straight up on the screen.
+The following shows the angles associated with the four major directions:
+
+			    0
+			    |
+			    |
+		  270  <----+---->  90
+			    |
+			    |
+			   180
+
+
+CONTINUE
+The current heading of the turtle is the integer value of the global variable
+HEADING.  The following TURN command is used to change the turtle's heading
+clockwise a given number of degrees relative to the current heading.  To keep
+the heading within bounds, the heading is computed modulo 360 degrees.
+
+$ (DEFUN TURN (ANGLE)
+    (SETQ HEADING (REM (+ HEADING ANGLE) 360)) )
+
+During this break, define the SETHEADING command.  This is similar to the TURN
+command except that the heading is simply set to the absolute heading given as
+an argument to the command.
+
+BREAK
+Our definition for the absolute SETHEADING command:
+
+$ (DEFUN SETHEADING (ANGLE)
+    (SETQ HEADING (REM ANGLE 360)) )
+
+
+CONTINUE
+We can control whether or not the turtle's "pen" is marking on the screen as
+it moves.  If the control variable PENDOWN is T, the turtle marks as it moves;
+if PENDOWN is NIL, the turtle does not mark.  Although we could use SETQ to
+make assignments to PENDOWN, it is more convenient to have functions for this
+purpose.  During this break define the functions PENDOWN and PENUP:
+
+BREAK
+Here are definitions for PENDOWN and PENUP:
+
+$ (DEFUN PENDOWN ()
+    (SETQ PENDOWN T) )
+
+$ (DEFUN PENUP ()
+    (SETQ PENDOWN NIL) )
+
+
+CONTINUE
+TURTLE is a convenient means of performing several successive turtle graphics
+commands.  TURTLE first positions the turtle in the center of the screen
+pointing North (i.e. heading 0) and puts the pen down.  DRAW is then called to
+switch to graphics mode and actually execute the commands.
+
+$ (DEFUN TURTLE (NLAMBDA COMMANDS
+    (SETPOS 0 0)
+    (SETHEADING 0)
+    (PENDOWN)
+    (APPLY 'DRAW COMMANDS) ))
+
+
+CONTINUE
+Finally, here is the definition for the FORWARD command:
+
+$ (DEFUN FORWARD (DISTANCE
+      X-OLD Y-OLD )
+    (SETQ X-OLD X-POS)
+    (SETQ Y-OLD Y-POS)
+    (INCQ X-POS (ROUND (* DISTANCE (SIN HEADING))))
+    (INCQ Y-POS (ROUND (* DISTANCE (COS HEADING))))
+    ((NOT PENDOWN))
+    (LINE X-OLD Y-OLD X-POS Y-POS) )
+
+During this break, draw an equilateral triangle using the TURTLE command:
+
+     (TURTLE (FORWARD 10) (TURN 120)
+	     (FORWARD 20) (TURN 120)
+	     (FORWARD 20) (TURN 120)
+	     (FORWARD 10))
+
+BREAK
+CLRSCRN
+We have ignored the fact that "aspect-ratio" of the width to height of a
+character is not 1 on most sceens.  For example, it is about 5/12 on the IBM
+PC in 80-character mode or about 5/6 on the IBM-PC in 40-character mode.  For
+this reason, you may prefer the lower angular distortion of 40-column mode if
+available.  (24 lines is the most severe cause of low-resolution, so half of
+the 80 columns is not much of a sacrifice.)
+
+Character graphics tends to be most satisfactory if you ignore the aspect
+ratio.  (You can always look at the screen from a compensatory slant!)
+However, we leave it as an exercise to account for the aspect ratio in the
+turtle graphics routines.
+
+
+CONTINUE
+Now we can begin a library of useful figures from which to compose more
+complicated figures.  As a simple start, it is convenient to have a command
+for advancing a given distance then turning a given angle:
+
+$ (DEFUN FORWARD-THEN-TURN (DISTANCE ANGLE)
+    (FORWARD DISTANCE)
+    (TURN ANGLE) )
+
+
+CONTINUE
+Next, it is useful to have a function that makes a polygon, ending up at the
+starting point and initial heading.  A theorem that the resulting total turn
+of a closed figure is 0 modulo 360 helps us know when to stop:
+
+$ (DEFUN POLY (SIDE ANGLE
+      TOT-TURN)
+    (SETQ TOT-TURN 0)
+    (LOOP
+      (FORWARD-THEN-TURN SIDE ANGLE)
+      (SETQ TOT-TURN (REM (+ TOT-TURN ANGLE) 360))
+      ((ZEROP TOT-TURN)) ) )
+
+During this break, experiment with POLY using various sides and angles.  For
+example, try
+
+	  (TURTLE (SETPOS -5 -10) (POLY 20 144))
+
+BREAK
+CLRSCRN
+Here is a challenging problem:  See if you can write a CORNER-POLY function
+which draws a polygon that recursively has a similar half-sized polygon
+outside each corner until the sides are reduced to one pixel.
+
+BREAK
+$ (DEFUN CORN-POL (SIDE ANGLE
+      TOT-TURN)
+    ((> SIDE 1)
+      (SETQ TOT-TURN 0)
+      (LOOP
+	(FORWARD SIDE)
+	(CORN-POL (SHIFT SIDE -2) (- ANGLE))
+	(TURN ANGLE)
+	(SETQ TOT-TURN (REM (+ TOT-TURN ANGLE) 360))
+	((ZEROP TOT-TURN)) ) ) )
+
+Note the use of the function SHIFT in the definition.  If <n> and <m> are
+integers and <m> is positive, (SHIFT n m) arithmetically shifts <n> LEFT <m>
+bits.  If <m> is negative, SHIFT arithmetically shifts <n> RIGHT -<m> bits.
+SHIFT is used above to efficiently divide an integer by 2.
+
+Try this call on CORN-POL for starters:
+
+	  (TURTLE (SETPOS -5 -5) (CORN-POL 8 90))
+
+BREAK
+CLRSCRN
+A spiral is another useful component.  Here is a definition that shrinks by
+subtracting a fixed increment from the side until the side becomes less than
+the increment:
+
+$ (DEFUN SPIRAL (SIDE ANGLE INCR)
+    (LOOP
+      ((< SIDE INCR))
+      (FORWARD-THEN-TURN SIDE ANGLE)
+      (DECQ SIDE INCR) ) )
+
+During this break, try
+
+	  (TURTLE (SETPOS -10 -12) (SPIRAL 23 90 1))
+
+BREAK
+CLRSCRN
+If SPIRAL is repeatedly called until the total turning reaches 0 modulo 360,
+then we will have a closed figure called a spirolateral.  Define the function
+SPIROLATERAL and experimentally determine some attractive spirolaterals.
+
+BREAK
+The spirolateral function:
+
+$ (DEFUN SPIROLAT (SIDE ANGLE INCR
+      TOT-TURN)
+    (SETQ TOT-TURN 0)
+    (LOOP
+       (SPIRAL SIDE ANGLE INCR)
+       (SETQ TOT-TURN (REM (+ TOT-TURN (* ANGLE (TRUNCATE SIDE INCR))) 360))
+       ((ZEROP TOT-TURN)) ) )
+
+Try this:
+
+	  (TURTLE (SETPOS 0 -6) (SPIROLAT 11 90 1))
+
+BREAK
+CLRSCRN
+Up till now we have been doing very low resolution, character "graphics".  If
+you have a computer capable of higher resolution graphics, you may want to
+take advantage of this capability.
+
+The graphics functions defined in this lesson work perfectly well for high
+resolution graphics if you make the following changes:
+
+1.  Redefine the point plotting function (DOT X-COORD Y-COORD) so it will
+    properly interface with your graphics hardware.
+
+2.  Define the functions GRAPHICS-MODE and ALPHA-MODE to switch the screen
+    between graphics and alpha modes.
+
+3.  If your computer is capable of color graphics, you can define a SETCOLOR
+    command.
+
+
+CONTINUE
+The following definition for a plot function is for the IBM PC and IBM
+"look-alike" computers:
+
+$ (DEFUN IBM-DOT (X-COORD Y-COORD)
+    ((AND (< -161 X-COORD 160)
+	  (< -101 Y-COORD 100) )
+      (REGISTER 2 (+ 160 X-COORD))
+      (REGISTER 3 (- 100 Y-COORD))
+      (REGISTER 0 *COLOR*)
+      (INTERRUPT 16) ) )
+
+
+If you are running muLISP on an IBM PC with a graphics display card (NOT a
+monochrome display card), issue the following command during this break:
+
+	(MOVD 'IBM-DOT 'DOT)
+
+BREAK
+CLRSCRN
+The following definitions are for the IBM PC and IBM PC "look-alikes":
+
+$ (DEFUN SETCOLOR (COLOR)
+    (SETQ *COLOR* (+ 3071 (LENGTH (MEMBER COLOR
+		'(WHITE RED GREEN BLACK))))) )
+
+$ (SETCOLOR WHITE)		;Sets color to white
+
+$ (DEFUN GRAPHICS-MODE ()	;Sets up 320 x 200 color graphics mode
+    (REGISTER 0 4)
+    (INTERRUPT 16)
+    (MAKE-WINDOW 0 0 25 40) )
+
+$ (DEFUN ALPHA-MODE ()		;Sets up 25 x 80 color alpha mode
+    (REGISTER 0 3)
+    (INTERRUPT 16)
+    (CURSOR-LINES NIL)
+    (MAKE-WINDOW 0 0 25 80) )
+
+
+CONTINUE
+The following definition for TURTLE is for the IBM PC and IBM "look-alikes":
+
+$ (DEFUN TURTLE (NLAMBDA COMMANDS
+    (IF (NEQ (CADDDR (MAKE-WINDOW)) 40) (GRAPHICS-MODE) )
+    (MAKE-WINDOW 0 0 21 40)
+    (SETPOS 0 0)
+    (SETHEADING 0)
+    (PENDOWN)
+    (CATCH 'DRIVER (APPLY 'DRAW COMMANDS))
+    (MAKE-WINDOW 21 0 4 40)
+    (SET-CURSOR 3 0) ))
+
+If you have modified DOT for high resolution graphics for your computer, try
+the following TURTLE command :
+
+	   (TURTLE (SETPOS -30 15) (SPIROLAT 87 90 3))
+
+BREAK
+$ (ALPHA-MODE)
+The use of recursion opens the door to really interesting designs and elegant
+graphics functions.  The following function makes the intricate "C" curve:
+
+$ (DEFUN C-CURVE (DEPTH)
+    ((ZEROP DEPTH)
+      (FORWARD *LENGTH*) )
+    (TURN 45)
+    (C-CURVE (SUB1 DEPTH))
+    (TURN -90)
+    (C-CURVE (SUB1 DEPTH))
+    (TURN 45) )
+
+$ (SETQ *LENGTH* 3)
+
+Try this pattern:  (TURTLE (TURN 270) (SETPOS 60 -30) (C-CURVE 11))
+
+BREAK
+$ (ALPHA-MODE)
+The following only slightly more complicated function draws the famous
+"Dragon" curve:
+
+$ (DEFUN D-CURVE (DEPTH FLAG)
+    ((ZEROP DEPTH)
+      (FORWARD *LENGTH*) )
+    (IF FLAG (TURN 45) (TURN -45))
+    (D-CURVE (SUB1 DEPTH) T)
+    (IF FLAG (TURN -90) (TURN 90))
+    (D-CURVE (SUB1 DEPTH) NIL)
+    (IF FLAG (TURN 45) (TURN -45)) )
+
+$ (SETQ *LENGTH* 3)
+
+Try this pattern:  (TURTLE (TURN 90) (SETPOS -60 0) (D-CURVE 11))
+
+BREAK
+$ (ALPHA-MODE)
+We have barely scratched the surface of what can be accomplished with turtle
+graphics.  If you would like to learn more, there are many good books on LOGO
+and turtle graphics.  One of the more advanced and thorough is "Turtle
+Graphics" by Harold Abelson and Andrea A. diSessa, (MIT Press, 1980).
+
+As a convenience to you, all the functions defined in this lesson have been
+included in the muLISP source file GRAPHICS.LIB.
+
+This concludes muLISP lesson #6.
+
+
+CONTINUE
+$ (RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/MULISP83.LSP b/Microsoft muLISP-86 v51/MULISP83.LSP
new file mode 100644
index 0000000..e6df6b3
--- /dev/null
+++ b/Microsoft muLISP-86 v51/MULISP83.LSP	
@@ -0,0 +1,128 @@
+; File: MULISP83.LSP (C)	12/29/85	Soft Warehouse, Inc.
+
+;			muLISP-83 Compatibility File
+
+
+; This file makes it possible for muLISP-86 to run muLISP-83 programs
+; with no or only a few changes required.  WARNING: This file should
+; NOT be read into a running muLISP-86 system more than once.
+
+(SETQ *READ-UPCASE* NIL)	;Turns off auto uppercase conversion.
+(SETQ *PRINT-ESCAPE* NIL)	;Turns off printing of escape chars.
+(SETQ PUTD NIL)			;Turns on full D-code condensing.
+
+(COPY-CHAR-TYPE '\" '\|)	;Make " a multiple escape char.
+
+(CSMEMORY 849 (ASCII '\"))	;Display multiple escape char as ".
+
+(COPY-CHAR-TYPE '\| 'A)		;Make | not a multiple escape char.
+
+(COPY-CHAR-TYPE (ASCII 12) 'A)	;Make <page> a constituent char.
+
+(COPY-CHAR-TYPE '"," '" ")	;Make , a whitespace char.
+
+				;Set up muLISP-83 break chars.
+(SET-BREAK-CHARS (CONS (ASCII 26)
+  '(! $ & "(" ")" * + "," - "." / : < = > ? @ "[" \\ "]" ^ _ ` { | } ~)))
+
+				;Make % a comment delimiter.
+(SET-MACRO-CHAR '"%" '(LAMBDA () (PEEK-CHAR '"%") (READ-CHAR)) 'COMMENT)
+
+				;Make ' a NONterminating macro char.
+(SET-MACRO-CHAR '"'" (GET-MACRO-CHAR '"'") T)
+
+(PUTD 'READ-LST (GET-MACRO-CHAR '"("))
+
+(PUTD 'READ-BRACKET '(LAMBDA (EXPN)
+  (SETQ EXPN (READ-LST))
+  ((EQ (PEEK-CHAR 'T) '"]")
+    (READ-CHAR) EXPN)
+  (CONS EXPN (READ-BRACKET)) ))
+
+(SET-MACRO-CHAR '"[" (GETD READ-BRACKET))  ;Make [ a super-parenthesis.
+
+(MOVD 'SYMBOLP 'NAME)
+(MOVD 'EQL 'EQ)
+(MOVD 'IDENTITY 'NONNULL)
+(MOVD '< 'LESSP)
+(MOVD '> 'GREATERP)
+(MOVD '+ 'PLUS)
+(MOVD '- 'DIFFERENCE)
+(MOVD '- 'MINUS)
+(MOVD '* 'TIMES)
+(MOVD 'CLEAR-SCREEN 'CLRSCRN)
+(MOVD 'SET-CURSOR 'CURSOR)
+
+
+; WARNING: The '86 functions TRUNCATE, REM, and DIVIDE return different
+; values than the '83 functions QUOTIENT, REMAINDER, and DIVIDE when
+; given negative arguments.  See the Reference Manual for details.
+
+(MOVD 'TRUNCATE 'QUOTIENT)
+(MOVD 'REM 'REMAINDER)
+
+(MOVD 'MEMBER 'MEMBER-AUX)
+(PUTD 'MEMBER '(LAMBDA (ITEM LST)
+  (MEMBER-AUX ITEM LST 'EQUAL) ))
+
+(MOVD 'ASSOC 'ASSOC-AUX)
+(PUTD 'ASSOC '(LAMBDA (ITEM LST)
+  (ASSOC-AUX ITEM LST 'EQUAL) ))
+
+(MOVD 'APPEND 'APPEND-AUX)
+(PUTD 'APPEND '(LAMBDA LST
+  ((NULL (CDR LST))
+    (COPY-LIST (CAR LST)) )
+  (APPLY 'APPEND-AUX LST) ))
+
+(PUTD 'NTH '(LAMBDA (ARG1 ARG2)
+  ((NUMBERP ARG2)
+    (NTHCDR (SUB1 ARG2) ARG1) )
+  (CAR (NTHCDR ARG1 ARG2)) ))
+
+(MOVD 'SUBSTRING 'SUBSTRING-AUX)
+(PUTD 'SUBSTRING '(LAMBDA (ARG N M)
+  ((NUMBERP N)
+    ((NUMBERP M)
+      (SUBSTRING-AUX ARG (SUB1 N) (SUB1 M)) )
+    (SUBSTRING-AUX ARG (SUB1 N)) )
+  ((NUMBERP M)
+    (SUBSTRING-AUX ARG N (SUB1 M)) )
+  (SUBSTRING-AUX ARG) ))
+
+(MOVD 'FINDSTRING 'FINDSTRING-AUX)
+(PUTD 'FINDSTRING '(LAMBDA (ARG1 ARG2 N)
+  ( ((NUMBERP N)
+      (DECQ N) ) )
+  (SETQ N (FINDSTRING-AUX ARG1 ARG2 N))
+  ((NUMBERP N)
+    (ADD1 N) )
+  N ))
+
+(PUTD 'READCH '(LAMBDA (FLAG
+    READ-CHAR )
+  (SETQ READ-CHAR READCH)
+  (SETQ RATOM (READ-CHAR FLAG))
+  ((LESSP 47 (ASCII RATOM) 58)
+    (SETQ RATOM (DIFFERENCE (ASCII RATOM) 48)) )
+  ((NULL READ)
+    (SETQ RATOM (STRING-UPCASE RATOM)) )
+  RATOM ))
+
+(PUTD 'READP '(LAMBDA (READ-CHAR)
+  (SETQ READ-CHAR READCH)
+  (LISTEN FLAG) ))
+
+(PUTD RADIX '(LAMBDA (NUM)
+  (PROG1 *READ-BASE* (SETQ *READ-BASE* NUM *PRINT-BASE* NUM)) ))
+
+(MOVD 'UNDEFINED 'UNDEFINED-AUX)
+(PUTD 'UNDEFINED '(LAMBDA #LST#
+  ((ATOM (CAR #LST#))
+    ((EQ (CAR #LST#) (CAAR #LST#))
+      (APPLY UNDEFINED-AUX #LST#) )
+    (EVAL (CONS (CAAR #LST#) (CDR #LST#))) )
+  (APPLY UNDEFINED-AUX #LST#) ))
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/README b/Microsoft muLISP-86 v51/README
new file mode 100644
index 0000000..fca96ca
--- /dev/null
+++ b/Microsoft muLISP-86 v51/README	
@@ -0,0 +1,46 @@
+    This is a summary of muLISP-86 features not yet incorporated into
+the Reference Manual:
+
+The file HELP.LSP provides a help facility for muLISP primitives.
+After it is read in, commands of the form (HELP name) or (? name)
+show <name>'s arguments, primitive type, and page number in
+Chapter 5 of the Reference Manual.
+
+The file STRUCTUR.LSP contains a structure facility (DEFSTRUCT) and
+an array facility (MAKE-ARRAY, AREF, ARRAY-RANK, ARRAY-DIMENSION,
+ARRAY-DIMENSIONS, ARRAY-TOTAL-SIZE, and ARRAY-IN-BOUNDS-P).
+See the file and Chapters 17 and 19 of Common LISP by Steele for
+documentation.
+
+The function DOS, defined in COMMON.LSP, simplifies the calling of
+the MS-DOS command processor.  For example:  (DOS "DIR B:/W").
+
+The function GENSYM, defined in COMMON.LSP, creates new symbols.
+(GENSYM) returns a new symbol.  If <n> is a nonnegative integer,
+(GENSYM n) sets the gensym counter to <n>.  (GENSYM symbol) sets
+the gensym prefix to <symbol>.
+
+A "backquote" macro character, defined in COMMON.LSP, facilitates
+defining macros using DEFMACRO.  See the file and pages 349-351 of
+Common LISP by Steele for documentation.
+
+The functions STRING-TRIM, STRING-RIGHT-TRIM, and STRING-LEFT-TRIM,
+defined in MULISP.COM, can now accept either a list or a symbol
+as its first argument (in accordance with Common LISP).
+
+The function STACK-LIST, defined in MULISP.COM, returns a list of
+the values currently on the muLISP variable stack.
+
+The muLISP editor command  Ctrl-Q L  repeats the last search and
+replace command until the end of the text is reached.
+
+If the muLISP editor control variable *CASE-IGNORE* is nonNIL,
+case is ignored when searching for a string.
+
+The muLISP editor variable *WINDOW-SHAPE* controls the initial
+dimensions of the edit window.  F for full screen, V for vertical
+split, H for horizontal split.
+
+A native code compiler for muLISP is now available from Soft
+Warehouse, Inc.  Write Soft Warehouse for details.
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/SIEVE.LSP b/Microsoft muLISP-86 v51/SIEVE.LSP
new file mode 100644
index 0000000..f81828a
--- /dev/null
+++ b/Microsoft muLISP-86 v51/SIEVE.LSP	
@@ -0,0 +1,49 @@
+; BYTE magazine's Sieve benchmark
+
+(setq size 8190)
+(setq a (make-array (+ size 1) :initial-element 0 ))
+(setq count 0)
+
+(defun kloop(k prime)
+    (loop
+        (when (> k size) (return 0))
+        (setf (aref a k) nil)
+        (setq k (+ k prime))
+    )
+)
+
+(defun runsieve() (prog ()
+    (setq i 0)
+    (setq count 0)
+    _nexti_
+        (cond ((<= i size)
+               (setf (aref a i) t)
+               (setq i (add1 i))
+               (go _nexti_))
+        )
+
+    (setq i 0)
+    _nexti2_
+        (cond ((<= i size)
+               (cond ((aref a i)
+                      (setq prime (+ i i 3))
+                      (kloop (+ i prime) prime)
+                      (setq count (add1 count)))
+               )
+               (setq i (add1 i))
+               (go _nexti2_))
+        )
+))
+
+(defun main() (prog ()
+    (princ "running...")
+    (setq startTime (time))
+
+    (dotimes (z 10) (runsieve))
+    (princ "count: ") (princ count)
+    (princ "elapsed hundredths of a second: ") (- (time) startTime)
+))
+
+(main)
+(system)
+
diff --git a/Microsoft muLISP-86 v51/STATE.SYS b/Microsoft muLISP-86 v51/STATE.SYS
new file mode 100644
index 0000000000000000000000000000000000000000..f05af96d1484cca9019f82e34221d722f10e9260
GIT binary patch
literal 33278
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
bGd|ye%@KcOI*d0{;o0!<z#QHTErkC7DQwvi

literal 0
HcmV?d00001

diff --git a/Microsoft muLISP-86 v51/STRUCTUR.LSP b/Microsoft muLISP-86 v51/STRUCTUR.LSP
new file mode 100644
index 0000000..66ec3e3
--- /dev/null
+++ b/Microsoft muLISP-86 v51/STRUCTUR.LSP	
@@ -0,0 +1,583 @@
+; File:	STRUCTUR.LSP  (C)	12/25/85	Soft Warehouse, Inc.
+
+; COMMON.LSP must also be read in to use the functions in this file.
+
+
+;			muLISP Array Facility
+
+; The muLISP array facility provides a subset of the Common LISP array
+; capability (see Chapter 17 of Common LISP, The Language by Guy L.
+; Steele Jr. [1984]).  Arrays are realized as 3-element lists of the form:
+
+;		(ARRAY <array-contents> <dims>)
+
+; where <array-contents> is a list of lists "compatible in length"
+; with <dims>, and <dims> is a list of zero or more positive integers.
+; Thus, arrays carry type and dimension information around with them
+; for fast array bounds checking.
+
+
+; Array Creation (see Steele, Section 17.1):
+
+; (MAKE-ARRAY <dimensions> {<option>}+) creates an array of dimensions
+; <dimensions>.
+
+; <dimensions> can be NIL, <dim>, or (<dim1> ... <dimn>).  <dim> must be
+; a POSITIVE integer (Common LISP only requires <dim> to be a
+; NON-NEGATIVE integer).
+
+; <option> is an array creation option of the form:
+;		 <keyword> <option-specifications>
+; where <keyword> is one of the array option keywords described below.
+; (Note: Keywords may be used in upper or lower case.)
+
+; :INITIAL-ELEMENT expression
+;   This option sets the initial value of each array element to <expression>.
+;   If the :INITIAL-ELEMENT option is not given, the initial value of each
+;   array element will be NIL.
+
+; :INITIAL-CONTENTS expression
+;   This option sets the initial contents of the array to a COPY of the
+;   elements of <expression>, if <expression> is "compatible in length"
+;   with the dimensions of the array (i.e. if the length of <expression>
+;   is equal to the first dimension of the array and each element of
+;   <expression> is "compatible in length" with the remaining dimensions
+;   of the array).  If the :INITIAL-CONTENTS option is not given, each
+;   array element will be determined in accordance with the
+;   :INITIAL-ELEMENT option.
+
+; The Common LISP array creation options :ELEMENT-TYPE, :ADJUSTABLE,
+; :FILL-POINTER, :DISPLACED-TO, and :DISPLACED-INDEX-OFFSET are NOT
+; supported.
+
+; MAKE-ARRAY can generate the following error breaks:
+
+; Dimension Error:  indicates that the dimension specification is
+;   neither NIL, a positive integer, nor a list of positive integers.
+
+; Incompatible Length:  indicates that the value specified for
+;   the :INITIAL-CONTENTS is NOT "compatible in length" with the
+;   dimensions of the array.
+
+
+(DEFMACRO MAKE-ARRAY (DIMS . OPTIONS)
+  (LIST 'MAKE-ARRAY-AUX DIMS (LIST 'QUOTE OPTIONS)) )
+
+(DEFUN MAKE-ARRAY-AUX (DIMS OPTIONS)
+  (IF (NUMBERP DIMS) (SETQ DIMS (LIST DIMS)))
+  ((AND (LISTP DIMS)
+	(EVERY '(LAMBDA (N) (AND (INTEGERP N) (PLUSP N)))
+	       DIMS) )
+    (LET ((conts (EVAL (CADR (MEMBER ':INITIAL-CONTENTS OPTIONS)))) )
+      ((NULL conts)
+	(LIST 'ARRAY
+	      (MAKE-ARRAY-CONTENTS DIMS
+		  (EVAL (CADR (MEMBER ':INITIAL-ELEMENT OPTIONS))))
+	       DIMS) )
+      ((ARRAY-CONTENTS-P DIMS conts)
+	(LIST 'ARRAY
+	      (COPY-ARRAY-CONTENTS DIMS conts)
+	      DIMS) )
+      (BREAK (LIST* 'MAKE-ARRAY DIMS OPTIONS) "Incompatible Length") ) )
+  (BREAK (LIST* 'MAKE-ARRAY DIMS OPTIONS) "Dimension Error") )
+
+(DEFUN MAKE-ARRAY-CONTENTS (DIMS INITELEM)
+; Creates an array contents structure "compatible in length" with DIMS,
+; and with INITELEM as the value of each element.
+  ((NULL (CDR DIMS))
+    (MAKE-LIST (CAR DIMS) INITELEM) )
+  (LET ((dim (CAR DIMS))
+	(aconts NIL) )
+    (LOOP
+      ((ZEROP dim) aconts)
+      (PUSH (MAKE-ARRAY-CONTENTS (CDR DIMS) INITELEM) aconts)
+      (DECQ dim) ) ) )
+
+(DEFUN ARRAY-CONTENTS-P (DIMS ACONTS)
+; Tests whether ACONTS is a list "compatible in length" with DIMS.
+  ((NULL DIMS) T)
+  ((= (LENGTH ACONTS) (CAR DIMS))
+    (EVERY '(LAMBDA (ELEM) (ARRAY-CONTENTS-P (CDR DIMS) ELEM) )
+	   ACONTS) ) )
+
+(DEFUN COPY-ARRAY-CONTENTS (DIMS ACONTS)
+; Copies ACONTS in accordance with DIMS.  Elements of ACONTS outside
+; the scope of DIMS (i.e. actual elements of the array) are NOT copied.
+  ((NULL (CDR DIMS))
+    (COPY-LIST ACONTS) )
+  (MAPCAR '(LAMBDA (ELEM) (COPY-ARRAY-CONTENTS (CDR DIMS) ELEM) )
+	  ACONTS) )
+
+
+; Array Access (see Steele, Section 17.2):
+
+; If <subscript1> ... <subscriptn> are non-negative integers,
+; (AREF <array> <subscript1> ... <subscriptn>) returns the specifed
+; element of <array>; and
+; (SETF (AREF <array> <subscript1> ... <subscriptn>) <expr>) sets the
+; specified element of <array> to the value of <expr>.
+
+; Note that AREF contains NO array bounds error checking.  This provides
+; good execution speed, but means that such checking must be done by the
+; user using the function ARRAY-IN-BOUNDS-P, defined below.
+
+(DEFMACRO AREF (ARRAY . SUBSCRIPTS)
+  (SETQ ARRAY (LIST 'CADR ARRAY))
+  (LOOP
+    ((NULL SUBSCRIPTS) ARRAY)
+    (SETQ ARRAY (LIST 'NTH (POP SUBSCRIPTS) ARRAY)) ) )
+
+
+; Array Information (see Steele, Section 17.3):
+
+(DEFUN ARRAY-RANK (ARRAY)
+; Returns the "rank" of ARRAY.
+  (LENGTH (CADDR ARRAY)) )
+
+(DEFUN ARRAY-DIMENSION (ARRAY AXISNUMBER)
+; Returns the dimension of ARRAY along the AXISNUMBER axis (where
+; 0 is the first axis of any array).
+  (NTH AXISNUMBER (CADDR ARRAY)) )
+
+(DEFUN ARRAY-DIMENSIONS (ARRAY)
+; Returns the list of dimensions of ARRAY.
+  (CADDR ARRAY) )
+
+(DEFUN ARRAY-TOTAL-SIZE (ARRAY)
+; Returns the total number of elements in ARRAY.
+  (REDUCE '* (CADDR ARRAY)) )
+
+(DEFUN ARRAY-IN-BOUNDS-P AREFSPEC
+; Tests whether AREFSPEC, an array/subscripts specification of
+; the form used in AREF, is within the bounds of the array.
+  (EVERY '(LAMBDA (I B) (AND (INTEGERP I) (< -1 I B)))
+	 (CDR AREFSPEC)
+	 (CADDAR AREFSPEC)) )
+
+
+;		muLISP Structure Facility
+
+; The muLISP structure facility provides a subset of the Common LISP
+; structure capability (see Chapter 19 of Common LISP, The Language
+; by Guy L. Steele Jr. [1984]).  Named structures are realized as lists
+; of the form:
+
+;		(<structname> <slot-1> <slot-2> ... <slot-n>)
+
+; Unnamed structures are realized as lists of the form:
+
+;		      (<slot-1> <slot-2> ... <slot-n>)
+
+; All structure functions -- constructors, accessors, copiers, and
+; predicates -- are implemented as MACROs.  This yields good execution
+; speed, and integrates nicely with the SETF implementation.  However,
+; there are some costs:
+; 1.  Structures must be defined BEFORE their functions are used.
+; 2.  Structure functions cannot be APPLYed, FUNCALLed, mapped down
+;     lists, etc., by themselves.  This can be accomplished by
+;     "wrapping" the function in a LAMBDA; for example, instead of
+;     (MAPCAR 'SLOT-NAME X) use (MAPCAR '(LAMBDA (S) (SLOT-NAME S)) X).
+; 3.  Redefining a structure will NOT cause all uses of structure
+;     functions to be redefined (i.e. re-expanded) UNLESS the
+;     control variable MACROEXPAND is NIL.  For this reason,
+;     it is recommended that MACROEXPAND be set to NIL during
+;     program development.  This will slow down execution speed
+;     during development, but make modifications much easier.
+
+; The structure functions contain NO execution or expansion time error
+; checking.  This provides good execution speed, but means that any
+; error checking needed must be supplied by the user.
+
+; Structure definition components -- options, slot names, slot values,
+; a :NAMED flag, and structure functions (MACROs) -- are stored on the
+; property list of the structure's name.  In addition, a list of the
+; structures supported is stored on the property list of each structure
+; function.  (See the functions PUTSTRUCT and REMSTRUCT below).
+
+
+; Structure Definition (see Steele, Section 19.2):
+
+; (DEFSTRUCT <name-and-options> {<slot-description>}+) creates a
+; structure data type.  <name-and-options> has the form <name> or
+; (<name> {<option>}+), where <name> is a symbol and <option> is a
+; DEFSTRUCT option (see below).  Each <slot-description> has the form
+; <slotname> or (<slotname> <expr>), where <slotname> is a symbol
+; and <expr> is any evaluable muLISP expression.  Note that "slot
+; options" are NOT supported.
+
+
+; Defstruct Options (see Steele, Section 19.5):
+
+; DEFSTRUCT options have the form <keyword> or
+; (<keyword> . <option-specifications>) where <keyword> is a defstruct
+; option keyword (Note: Keywords may be used in upper or lower case).
+
+; :CONC-NAME prefix
+;   This option modifies the default prefix naming of <slotname>'s
+;   accessor function as follows:
+;   1.	If the :CONC-NAME option is not given, the accessor function
+;	will be named (PACK* <structname> "-" <slotname>).
+;   2.	If <prefix> is a nonNIL symbol, the accessor function will be
+;	named (PACK* <prefix> <slotname>).
+;   3.	If <prefix> is NIL, the accessor function will be named
+;	<slotname> (i.e. with NO prefix).
+
+; :CONSTRUCTOR consname [arglist]
+;   This option modifies the default naming of the standard keyword
+;   constructor function and specifies additional positional
+;   constructor functions as follows:
+;   1.	If the :CONSTRUCTOR option is not given, a standard keyword
+;	constructor named (PACK* "MAKE-" <structname>) will be provided.
+;   2.	If <consname> is a nonNIL symbol, a standard keyword
+;	constructor named <consname> will be provided.
+;   3.	If <consname> is NIL, NO keyword constructor will be provided.
+;   4.	If <consname> is a symbol and <arglist> is a list of names of
+;	slots of the structure, a positional constructor named
+;	<consname> will be provided.
+;   (Note that more than one :CONSTRUCTOR option can be included in a
+;   structure definition.)
+
+; :COPIER copyname
+;   This option modifies the default naming of the standard copier
+;   function as follows:
+;   1.	If the :COPIER option is not given, a standard copier named
+;	(PACK* "COPY-" <structname>) will be provided.
+;   2.	If <copyname> is a nonNIL symbol, a standard copier named
+;	<copyname> will be provided.
+;   3.	If <copyname> is NIL, NO copier will be provided.
+
+; :PREDICATE predname
+;   This option modifies the default naming of the standard predicate
+;   function of named structures as follows:
+;   1.	If the :PREDICATE option is not given, a standard predicate
+;	named (PACK* <structname> "-P") will be provided.
+;   2.	If <predname> is a nonNIL symbol, a standard predicate named
+;	<predname> will be provided.
+;   3.	If <predname> is NIL, NO predicate will be provided.
+
+; :INCLUDE inclstruct {<slotdescrip>}+
+;   This option includes the slots of a previously defined structure
+;   in the structure being defined (the structure being defined
+;   becomes an extension and specialization of the :INCLUDEd structure)
+;   as follows:
+;   1.	If the :INCLUDE option is not given, no other structure will
+;	be included.
+;   2.	If <inclstruct> is a previously defined structure, the structure
+;	being defined will include the slots of <inclstruct>.
+;   3.	If <inclstruct> is a previously defined structure and each
+;	<slotdescrip> describes a slot in <inclstruct>, the structure
+;	being defined will include the slots of <inclstruct>, but with
+;	original default values overridden by {<slotdescrip>}+.
+;   (Note that included structures must be :NAMED or not :NAMED
+;   consistently with the structure being defined.)
+
+; :TYPE LIST
+;   This option used in conjunction with the :NAMED option forces a
+;   particular representation for the structure being defined as follows:
+;   1.	If the :TYPE option is not given, the structure being defined
+;	will be represented as a list and will be :NAMED.
+;   2.	If the :TYPE option is given, the structure being defined
+;	will be represented as a list and will NOT be :NAMED, unless
+;	the structure definition explicitly specifies the :NAMED option.
+;   (Note that only the type LIST is valid.)
+
+; :NAMED
+;   This option used in conjunction with the :TYPE option forces a
+;   particular representation for the structure being defined as follows:
+;   1.	If the :NAMED option is not given, the structure being defined
+;	will be :NAMED unless an explicit :TYPE option is specified.
+;   2.	If the :NAMED option is given, the structure being defined will
+;	be :NAMED irrespective of any :TYPE specifications.
+
+; The Common LISP DEFSTRUCT options :PRINT-FUNCTION and :INITIAL-OFFSET
+; are NOT supported.
+
+
+; DEFSTRUCT can generate the following error breaks:
+
+; Nonsymbolic Argument:  indicates that a nonsymbol was given as the
+;   name for a structure or a slot in the structure.
+
+; Unsupported Option:  indicates that an unsupported DEFSTRUCT option
+;   was given.
+
+; Unnamed Structure:  indicates that a predicate option was given for
+;   an unnamed structure.
+
+; Undefined Structure:  indicates that the name of an undefined
+;   structure was given for inclusion in a structure.
+
+; Include Error:  indicates that a named structure was given for inclusion
+;   in an unnamed structure, or that an unnamed structure was given for
+;   inclusion in a named structure.
+
+; Incompatible definition:  indicates that a definition for a function
+;   is incompatible with the existing definition of the function.
+
+
+(DEFMACRO DEFSTRUCT (STRUCTSPEC . SLOTSPECS)
+  (LIST 'DEFSTRUCT-AUX
+	(LIST 'QUOTE STRUCTSPEC)
+	(LIST 'QUOTE SLOTSPECS)) )
+
+(DEFUN DEFSTRUCT-AUX (STRUCTSPEC SLOTSPECS)
+  (LET* ((name (GET-STRUCT-NAME STRUCTSPEC))
+	 (options (GET-STRUCT-OPTIONS name STRUCTSPEC))
+	 (slotnams (GET-STRUCT-SLOT-NAMES name SLOTSPECS))
+	 (slotvals (GET-STRUCT-SLOT-VALUES name SLOTSPECS))
+	 (named? (OR (ASSOC ':NAMED options)
+		     (NOT (ASSOC ':TYPE options))) ) )
+    (LET ((istruct (ASSOC ':INCLUDE options)) )
+      ((CHECK-INCLUDED-STRUCT name istruct named?)
+	(SETQ slotnams
+	      (APPEND (GET (CADR istruct) 'STRUCT-SLOTNAMES)
+		      slotnams))
+	(SETQ slotvals
+	      (MAPCAR '(LAMBDA (SNAM SVAL)
+			   ((CADR (ASSOC SNAM (CDDR istruct))) )
+			   SVAL)
+		      slotnams
+		      (APPEND (GET (CADR istruct) 'STRUCT-SLOTVALS)
+			      slotvals))) ) )
+    (PUTSTRUCT name options slotnams slotvals named?
+	(CHECK-STRUCT-MACDEFS name
+	    (APPEND (FORM-STRUCT-CONSTRUCTORS name options slotnams
+					      slotvals named?)
+		    (FORM-STRUCT-ACCESSORS name options slotnams
+					   named?)
+		    (FORM-STRUCT-PREDICATE name options named?)
+		    (FORM-STRUCT-COPIER name options)))) ) )
+
+
+(DEFUN GET-STRUCT-NAME (STRUCTSPEC)
+; Extracts and returns the structure name specification from STRUCTSPEC,
+; verifying that it is a symbol.
+  (LET ((stnam (IF (CONSP STRUCTSPEC) (CAR STRUCTSPEC) STRUCTSPEC) ) )
+    ((SYMBOLP stnam) stnam)
+    (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS) "Nonsymbolic Argument") ) )
+
+(DEFUN GET-STRUCT-OPTIONS (NAME STRUCTSPEC)
+; Extracts the structure option specifications from STRUCTSPEC, verifying
+; that each is a supported option.  Collects and returns the options in
+; a uniform "a-list" format.
+  ((ATOM STRUCTSPEC) NIL)
+  (MAPCAR '(LAMBDA (OPT)
+	       (LET ((optnam (IF (CONSP OPT) (CAR OPT) OPT) ) )
+		 ((AND (SYMBOLP optnam)
+		       (MEMBER (SETQ optnam (STRING-UPCASE optnam))
+			       '(:CONC-NAME :CONSTRUCTOR :COPIER
+				 :PREDICATE :INCLUDE :TYPE :NAMED)) )
+		   (CONS optnam (IF (CONSP OPT) (CDR OPT))) )
+		 (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+			"Unsupported Option") ) )
+	  (CDR STRUCTSPEC)) )
+
+(DEFUN GET-STRUCT-SLOT-NAMES (NAME SLOTSPECS)
+; Extracts the structure slot names from SLOTSPECS, verifying that each
+; is a symbol.  Returns a list of the slot names.
+  (MAPCAR '(LAMBDA (SLOT)
+	       (LET ((snam (IF (CONSP SLOT) (CAR SLOT) SLOT)) )
+		 ((SYMBOLP snam) snam)
+		 (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+			"Nonsymbolic Argument") ) )
+	  SLOTSPECS) )
+
+(DEFUN GET-STRUCT-SLOT-VALUES (NAME SLOTSPECS)
+; Extracts the structure slot values from SLOTSPECS, supplying NIL as
+; the value for any slot without a specified value.  Returns a list of
+; the slot values.
+  (MAPCAR '(LAMBDA (SLOT) (IF (CONSP SLOT) (CADR SLOT)))
+	  SLOTSPECS) )
+
+
+(DEFUN CHECK-INCLUDED-STRUCT (NAME ISTRUCT NAMED?)
+; Checks that the (:INCLUDE ...) option ISTRUCT (if any) specifies a
+; valid, previously defined structure which is compatible with the
+; structure being defined.
+  ((NULL ISTRUCT) NIL)
+  (LET ((iname (CADR ISTRUCT)) )
+    ((GET iname 'STRUCT-MACROS)
+      ((GET iname 'NAMED-STRUCT)
+	((IDENTITY NAMED?) T)
+	(BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+	       "Include Error") )
+      ((NOT NAMED?) T)
+      (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+	     "Include Error") )
+    (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+	   "Undefined Structure") ) )
+
+(DEFUN CHECK-STRUCT-MACDEFS (NAME MACDEFS)
+; Checks that each MACRO (<name> . <definition>) pair in the list
+; MACDEFS will NOT cause an incompatible redefinition of an existing
+; function.
+  (MAPCAR '(LAMBDA (MACDEF)
+	       ((OR (NULL (GETD (CAR MACDEF) T))
+		    (EQUAL (GETD (CAR MACDEF)) (CDR MACDEF)) )
+		  MACDEF)
+	       (IF (NULL (GET (CAR MACDEF) 'STRUCTS))
+		   (PUT (CAR MACDEF) 'STRUCTS (CONS)) )
+	       ((NULL (REMOVE NAME (GET (CAR MACDEF) 'STRUCTS)))
+		  MACDEF)
+	       (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+		      "Incompatible Definition") )
+	MACDEFS) )
+
+
+(DEFUN FORM-STRUCT-CONSTRUCTORS (NAME OPTIONS SLOTNAMS SLOTVALS NAMED?)
+; Formulates constructor functions as MACROs for the structure NAME in
+; accordance with OPTIONS, SLOTNAMS, SLOTVALS, and NAMED?.  Returns a
+; list of constructor function (<name> . <definition>) pairs (or NIL
+; if no constructor functions were desired).
+  (LET ((consopt (ASSOC ':CONSTRUCTOR OPTIONS)) )
+    ((NULL consopt)
+      (LIST (CONS (PACK* 'MAKE- NAME)
+		  (STRUCT-KEYWORD-CONSTRUCTOR NAME SLOTNAMS SLOTVALS
+			NAMED?))) )
+    (MAPCAN '(LAMBDA (OPT)
+		 ((EQ (CAR OPT) ':CONSTRUCTOR)
+		   ((NULL (CDR OPT))
+		     (LIST (CONS (PACK* 'MAKE- NAME)
+				 (STRUCT-KEYWORD-CONSTRUCTOR NAME
+				       SLOTNAMS SLOTVALS NAMED?))) )
+		   ((NULL (CADR OPT)) )
+		   ((NULL (CDDR OPT))
+		     (LIST (CONS (CADR OPT)
+				 (STRUCT-KEYWORD-CONSTRUCTOR NAME
+				       SLOTNAMS SLOTVALS NAMED?))) )
+		   (LIST (CONS (CADR OPT)
+			       (STRUCT-POSITIONAL-CONSTRUCTOR NAME
+				     SLOTNAMS SLOTVALS (CADDR OPT)
+				     NAMED?))) ) )
+	    OPTIONS) ) )
+
+(DEFUN STRUCT-KEYWORD-CONSTRUCTOR (NAME SLOTNAMS SLOTVALS NAMED?)
+; Formulates a keyword constructor function as a MACRO for the structure
+; NAME in accordance with SLOTNAMS, SLOTVALS, and NAMED?.  Returns the
+; definition for the constructor.
+  (LIST 'MACRO
+	'SLOTSPECS
+	(APPEND '(LIST* 'LIST)
+		(IF NAMED? (LIST (LIST 'QUOTE (LIST 'QUOTE NAME))))
+		(LIST (LIST 'MAPCAR
+			    ''(LAMBDA (SNAM SVAL)
+				  (LET ((spec (MEMBER (PACK* '":" SNAM)
+						      SLOTSPECS)) )
+				    ((NULL spec) SVAL)
+				    (CADR spec) ) )
+			    (LIST 'QUOTE SLOTNAMS)
+			    (LIST 'QUOTE SLOTVALS) ) ) ) ) )
+
+(DEFUN STRUCT-POSITIONAL-CONSTRUCTOR (NAME SLOTNAMS SLOTVALS ARGS NAMED?)
+; Formulates a positional constructor as a MACRO for the structure NAME
+; in accordance with SLOTNAMS, SLOTVALS, ARGS, and NAMED?.  Returns the
+; definition for the constructor.
+  (LIST 'MACRO
+	'BODY
+	(APPEND '(LIST 'LIST)
+		(IF NAMED? (LIST (LIST 'QUOTE (LIST 'QUOTE NAME))))
+		(MAPCAR '(LAMBDA (SNAM SVAL)
+			     ((MEMBER SNAM ARGS)
+			       (LIST 'NTH
+				     (ADD1 (POSITION SNAM ARGS))
+				     'BODY) )
+			     SVAL)
+			SLOTNAMS
+			SLOTVALS) ) ) )
+
+(DEFUN FORM-STRUCT-ACCESSORS (NAME OPTIONS SLOTNAMS NAMED?)
+; Formulates accessor functions as MACROs for the structure NAME in
+; accordance with OPTIONS, SLOTNAMS, and NAMED?.  Returns a list of
+; accessor function  (<name> . <definition>) pairs.
+  (LET ((namopt (ASSOC ':CONC-NAME OPTIONS)) )
+    (LET ((prefix (COND ((OR (NULL namopt)
+			     (NULL (CDR namopt)) )
+			  (PACK* NAME '"-") )
+			((NULL (CADR namopt)) '"")
+			((CADR namopt)) ) )
+	  (slotpsn (IF NAMED? 1 0)) )
+      (MAPCAR '(LAMBDA (SNAM)
+		  (CONS (PACK* prefix SNAM)
+			(LIST 'MACRO 'BODY
+			      (LIST 'LIST ''NTH slotpsn (LIST 'CADR 'BODY)))
+			(INCQ slotpsn)) )
+	      SLOTNAMS) ) ) )
+
+(DEFUN FORM-STRUCT-PREDICATE (NAME OPTIONS NAMED?)
+; Formulates a predicate function as a MACRO for the structure NAME in
+; accordance with OPTIONS and NAMED?.  Returns a list consisting of the
+; predicate function (<name> . <definition>) pair (or NIL if no predicate
+; function was desired).
+  (LET ((predopt (ASSOC ':PREDICATE OPTIONS)) )
+    ((NOT NAMED?)
+      ((OR (NULL predopt)
+	   (AND (CDR predopt)
+		(NULL (CADR predopt)) ) ) )
+      (BREAK (LIST* 'DEFSTRUCT STRUCTSPEC SLOTSPECS)
+	     "Unnamed Structure") )
+    ((OR (NULL predopt)
+	 (NULL (CDR predopt))
+	 (CADR predopt))
+      (LIST (CONS (IF (OR (NULL predopt) (NULL (CDR predopt)))
+		      (PACK* NAME '"-P")
+		      (CADR predopt) )
+		  (LIST 'MACRO
+			'BODY
+			(LIST 'LIST
+			      ''EQ
+			      (LIST 'LIST
+				    ''CAR
+				    (LIST 'CADR 'BODY))
+			      (LIST 'QUOTE (LIST 'QUOTE NAME)))) ) ) ) ) )
+
+(DEFUN FORM-STRUCT-COPIER (NAME OPTIONS)
+; Formulates a copier function as a MACRO for the structure NAME in
+; accordance with OPTIONS.  Returns a list consisting of the copier
+; function (<name> . <definition>) pair (or NIL if no copier function
+; was desired).
+  (LET ((copyopt (ASSOC ':COPIER OPTIONS)) )
+    ((OR (NULL copyopt)
+	 (NULL (CDR copyopt))
+	 (CADR copyopt))
+      (LIST (CONS (IF (OR (NULL copyopt) (NULL (CDR copyopt)))
+		      (PACK* 'COPY- NAME)
+		      (CADR copyopt) )
+		  (LIST 'MACRO
+			'BODY
+			(LIST 'LIST
+			      ''COPY-LIST
+			      (LIST 'CADR 'BODY)) ) ) ) ) ) )
+
+
+(DEFUN PUTSTRUCT (NAME OPTIONS SLOTNAMS SLOTVALS NAMED? MACDEFS)
+; Installs the structure NAME.
+  (IF (GET NAME 'STRUCT-MACROS) (REMSTRUCT NAME) )
+  (PUT NAME 'STRUCT-OPTIONS OPTIONS)
+  (PUT NAME 'STRUCT-SLOTNAMES SLOTNAMS)
+  (PUT NAME 'STRUCT-SLOTVALS SLOTVALS)
+  (PUT NAME 'NAMED-STRUCT NAMED?)
+  (PUT NAME 'STRUCT-MACROS
+       (MAPCAR '(LAMBDA (MACDEF)
+		    (PUT (CAR MACDEF) 'STRUCTS
+			 (CONS NAME (GET (CAR MACDEF) 'STRUCTS)))
+		    (PUTD (CAR MACDEF) (CDR MACDEF)) )
+	       MACDEFS))
+  NAME )
+
+(DEFUN REMSTRUCT (NAME)
+; Removes the structure NAME.
+  (REMPROP NAME 'STRUCT-OPTIONS)
+  (REMPROP NAME 'STRUCT-SLOTNAMES)
+  (REMPROP NAME 'STRUCT-SLOTVALS)
+  (REMPROP NAME 'NAMED-STRUCT)
+  (MAPC '(LAMBDA (MACDEF)
+	     (LET ((sts (REMOVE NAME (GET MACDEF 'STRUCTS))) )
+	       ((NULL sts)
+		 (REMPROP MACDEF 'STRUCTS)
+		 (REMD MACDEF) )
+	       (PUT MACDEF 'STRUCTS sts) ) )
+	(GET NAME 'STRUCT-MACROS) )
+  (REMPROP NAME 'STRUCT-MACROS) )
+
+(RDS)
+
\ No newline at end of file
diff --git a/Microsoft muLISP-86 v51/TTT.LSP b/Microsoft muLISP-86 v51/TTT.LSP
new file mode 100644
index 0000000..e2ad82b
--- /dev/null
+++ b/Microsoft muLISP-86 v51/TTT.LSP	
@@ -0,0 +1,212 @@
+; Prove you can't win at tic-tac-toe if the opponent is competent.
+; written for Microsoft Lisp v5 (muLISP-86)
+; requires common.lsp and structur.lsp to have been loaded
+
+(setq score-win 6)
+(setq score-tie 5)
+(setq score-lose 4)
+(setq score-max 9)
+(setq score-min 2)
+(setq piece-blank 0)
+(setq piece-x 1)
+(setq piece-o 2)
+(setq moves 0)
+(setq board (make-array 9 :initial-element 0 ))
+(setq winpiece piece-blank)
+
+(defun iswin (x y z)
+    (setq winpiece (cxr x board))
+    (cond ((and (not (= winpiece piece-blank)) (= winpiece (cxr y board)) (= winpiece (cxr z board)))))
+)
+
+(defun winner()
+    (cond ((or (iswin 0 1 2)
+               (iswin 0 3 6)
+               (iswin 1 4 7)
+               (iswin 2 5 8)
+               (iswin 3 4 5)
+               (iswin 4 0 8)
+               (iswin 4 2 6)
+               (iswin 6 7 8))
+            winpiece)
+          (t piece-blank)
+    )
+)
+
+(defun proc0(x)
+    (cond ((or (and (= x (aref board 1)) (= x (aref board 2)))
+               (and (= x (aref board 3)) (= x (aref board 6)))
+               (and (= x (aref board 4)) (= x (aref board 8))))
+           x) (t piece-blank))
+)
+
+(defun proc1(x)
+    (cond ((or (and (= x (aref board 0)) (= x (aref board 2)))
+               (and (= x (aref board 4)) (= x (aref board 7))))
+           x) (t piece-blank))
+)
+
+(defun proc2(x)
+    (cond ((or (and (= x (aref board 0)) (= x (aref board 1)))
+               (and (= x (aref board 5)) (= x (aref board 8)))
+               (and (= x (aref board 4)) (= x (aref board 6))))
+           x) (t piece-blank))
+)
+
+(defun proc3(x)
+    (cond ((or (and (= x (aref board 4)) (= x (aref board 5)))
+               (and (= x (aref board 0)) (= x (aref board 6))))
+           x) (t piece-blank))
+)
+
+(defun proc4(x)
+    (cond ((or (and (= x (aref board 0)) (= x (aref board 8)))
+               (and (= x (aref board 2)) (= x (aref board 6)))
+               (and (= x (aref board 1)) (= x (aref board 7)))
+               (and (= x (aref board 3)) (= x (aref board 5))))
+           x) (t piece-blank))
+)
+
+(defun proc5(x)
+    (cond ((or (and (= x (aref board 3)) (= x (aref board 4)))
+               (and (= x (aref board 2)) (= x (aref board 8))))
+           x) (t piece-blank))
+)
+
+(defun proc6(x)
+    (cond ((or (and (= x (aref board 7)) (= x (aref board 8)))
+               (and (= x (aref board 0)) (= x (aref board 3)))
+               (and (= x (aref board 2)) (= x (aref board 4))))
+           x) (t piece-blank))
+)
+
+(defun proc7(x)
+    (cond ((or (and (= x (aref board 6)) (= x (aref board 8)))
+               (and (= x (aref board 1)) (= x (aref board 4))))
+           x) (t piece-blank))
+)
+
+(defun proc8(x)
+    (cond ((or (and (= x (aref board 6)) (= x (aref board 7)))
+               (and (= x (aref board 2)) (= x (aref board 5)))
+               (and (= x (aref board 0)) (= x (aref board 4))))
+           x) (t piece-blank))
+)
+
+(defun mmMax (alpha beta depth move) (prog (i value nextDepth) ; this is how local variables are declared
+    (setq moves (+ 1 moves))
+    ;(princ "max: ") (princ board) (princ " ") (princ alpha) (princ " ") (princ beta) (princ " ") (princ move) (princ " ") (princ depth) (princ "\n")
+
+    (cond ((> depth 3)
+           ;(setq win (winner)) ; almost 2x slower than using procs
+           ;(setq win (funcall (concat 'proc move) piece-o)) ; slower than using the procs hunk
+           (setq win (funcall (aref procs move) piece-o))
+           (cond ((= win piece-o) (return score-lose))))
+    )
+
+    (setq value score-min)
+    (setq nextDepth (+ 1 depth))
+    (setq i 0)
+    _nexti_
+    (cond ((= (aref board i) piece-blank)
+           (setf (aref board i) piece-x)
+           (setq score (mmMin alpha beta nextDepth i))
+           (setf (aref board i) piece-blank)
+                                       
+           (cond ((= score score-win) 
+                  (return score-win)) 
+                 ((> score value)
+                  (setq value score)
+                  (cond ((>= value beta)
+                         (return value))
+                        ((> value alpha)
+                         (setq alpha value))))
+           ))
+    )
+
+    (cond ((< i 8)
+           (setq i (+ i 1))
+           (go _nexti_))
+    )
+
+    (return value)
+))
+
+(defun mmMin (alpha beta depth move) (prog (i value nextDepth) ; this is how local variables are declared
+    (setq moves (+ 1 moves))
+    ;(princ "min: ") (princ board) (princ " ") (princ alpha) (princ " ") (princ beta) (princ " ") (princ move) (princ " ") (princ depth) (princ "\n")
+
+    (cond ((> depth 3)
+           ;(setq win (winner)) ; almost 2x slower than using procs
+           ;(setq win (funcall (concat 'proc move) piece-x)) ; slower than using the procs hunk
+           (setq win (funcall (aref procs move) piece-x))
+           (cond ((= win piece-x) (return score-win))
+                 ((= depth 8) (return score-tie))
+           ))
+    )
+
+    (setq value score-max)
+    (setq nextDepth (+ 1 depth))
+    (setq i 0)
+    _nexti_
+    (cond ((= (aref board i) piece-blank)
+           (setf (aref board i) piece-o)
+           (setq score (mmMax alpha beta nextDepth i))
+           (setf (aref board i) piece-blank)
+
+           (cond ((= score score-lose) 
+                  (return score-lose)) 
+                 ((< score value)
+                  (setq value score)
+                  (cond ((<= value alpha)
+                         (return value)) 
+                        ((< value beta)
+                         (setq beta value))))
+           ))
+    )
+
+    (cond ((< i 8)
+           (setq i (+ i 1))
+           (go _nexti_))
+    )
+
+    (return value)
+))
+
+(defun runmm (position)
+    (setf (aref board position) piece-x)
+    (mmMin score-min score-max 0 position)
+    (setf (aref board position) piece-blank)
+    (return "")
+)
+
+(setq procs (make-array 9))
+(setf (aref procs 0) proc0)
+(setf (aref procs 1) proc1)
+(setf (aref procs 2) proc2)
+(setf (aref procs 3) proc3)
+(setf (aref procs 4) proc4)
+(setf (aref procs 5) proc5)
+(setf (aref procs 6) proc6)
+(setf (aref procs 7) proc7)
+(setf (aref procs 8) proc8)
+
+(defun runall ()
+    (runmm 0)
+    (runmm 1)
+    (runmm 4)                      
+)
+
+(clear-screen)
+(setq startTime (time))
+(dotimes (z 10) (runall))
+
+(write-string "moves: ") (princ moves) ; should be 6493
+(princ "elapsed hundredths of a second: ") (- (time) startTime) (TERPRI)
+
+;(princ "memstat:         ") (princ (memstat)) (princ "\n")
+;(gc)
+;(princ "memstat post gc: ") (princ (memstat)) (princ "\n")
+
+(system)
+
diff --git a/Microsoft muLISP-86 v51/m.bat b/Microsoft muLISP-86 v51/m.bat
new file mode 100644
index 0000000..fcc359e
--- /dev/null
+++ b/Microsoft muLISP-86 v51/m.bat	
@@ -0,0 +1,5 @@
+copy common.lsp+structur.lsp+%1.lsp foo.lsp
+REM first remove (rds) twice from foo.lsp
+type foo.lsp | findstr /i /B /V (RDS) >bar.lsp
+ntvdm -p -c mulisp bar.lsp
+