anchor.diff:  
   (DEFMACRO if (X Y Z)
     `(LET ((*C* ,X))
  -       (COND ((EQ *C* 'true) ,Y)
  -             ((EQ *C* 'false) ,Z)
  -             (T (ERROR "~S is not a boolean~%" *C*)))))
  +    (COND ((EQ *C* 'true)
  +           ,Y)
  +          ((EQ *C* 'false)
  +           ,Z)
  +          (T
  +           (ERROR "~S is not a boolean~%" *C*)))))
   
   (DEFMACRO and (X Y) `(if ,X (if ,Y 'true 'false) 'false))
   
  
positive.code: 
  (DEFUN shen.multiply (X Y)
    (IF (OR (ZEROP X) (ZEROP Y))
        0
        (* (shen.double-precision X)(shen.double-precision Y))))
  
  (DEFUN shen.add (X Y)
    (+ (shen.double-precision X)(shen.double-precision Y)))
  
  (DEFUN shen.subtract (X Y)
    (- (shen.double-precision X)(shen.double-precision Y)))
  
  (DEFUN shen.divide (X Y)
    (LET ((Div (/ (shen.double-precision X)
                  (shen.double-precision Y))))
                        (IF (INTEGERP Div)
                             Div
                            (* (COERCE 1.0 'DOUBLE-FLOAT) Div))))
  
  (DEFUN shen.greater? (X Y) (IF (> X Y) 'true 'false))
  
  (DEFUN shen.less? (X Y) (IF (< X Y) 'true 'false))
  
  (DEFUN shen.greater-than-or-equal-to? (X Y)
  	(IF (>= X Y) 'true 'false))
  
  (DEFUN shen.less-than-or-equal-to? (X Y)
  	(IF (<= X Y) 'true 'false))
  
  (SETF *STANDARD-TWO-WAY* (MAKE-TWO-WAY-STREAM *STANDARD-INPUT* *STANDARD-OUTPUT*))
  (SETQ *stinput* *STANDARD-TWO-WAY*)
  (SETQ *stoutput* *STANDARD-OUTPUT*)
  (SETQ *sterror* *ERROR-OUTPUT*)
  
  (DEFUN number? (N) (IF (NUMBERP N) 'true 'false))
  
  (DEFUN SHEN-TOPLEVEL ()
    (HANDLER-CASE (shen.shen)
     (SB-SYS:INTERACTIVE-INTERRUPT ()
       (FORMAT T "~%Quit.~%")
       (exit 0))))
  
negative.code: 
  (DECLAIM (INLINE read-byte))
  
  (DEFUN read-byte (S) (READ-BYTE S NIL -1))
  
  (DEFUN open (String Direction)
    (LET ((Path (FORMAT NIL "~A~A" *home-directory* String)))
      (shen.openh Path Direction)))
  
  (DEFUN shen.openh (Path Direction)
    (COND ((EQ Direction 'in)
           (OPEN Path
            :DIRECTION    :INPUT
            ; :ELEMENT-TYPE 'UNSIGNED-BYTE
            :ELEMENT-TYPE :DEFAULT))
          ((EQ Direction 'out)
           (OPEN Path
            :DIRECTION    :OUTPUT
            ; :ELEMENT-TYPE 'UNSIGNED-BYTE
            :ELEMENT-TYPE :DEFAULT
            :IF-EXISTS    :SUPERSEDE))
          (T
           (ERROR "invalid direction"))))
  
  (DEFUN type (X MyType) (DECLARE (IGNORE MyType)) X)
  
  