anchor.diff:  (DEFUN simple-error (String) (ERROR "~A" String))
   
   (DEFMACRO trap-error (X F)
  -`(HANDLER-CASE ,X (ERROR (Condition) (FUNCALL ,F Condition))))
  +  `(HANDLER-CASE ,X (ERROR (Condition) (FUNCALL ,F Condition))))
   
   (DEFUN error-to-string (E)
      (IF (TYPEP E 'CONDITION)
  
positive.code: 
  (DECLAIM (INLINE read-byte))
  
  (DEFUN read-byte (S)
    (READ-BYTE S NIL -1))
  
  ;(DEFUN eos? (Stream)
   ;  (IF (LISTEN Stream) 'false 'true))
  
  (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))
            ;  ((EQ Direction 'out)
             ;  (OPEN Path :DIRECTION :OUTPUT
              ;            :ELEMENT-TYPE 'UNSIGNED-BYTE
                ;          :IF-EXISTS :SUPERSEDE))
             ; (T (ERROR "invalid direction"))))
  
  (DEFUN shen.openh (Path Direction)
        (COND ((EQ Direction 'in)
               (OPEN Path :DIRECTION :INPUT
                          :ELEMENT-TYPE :DEFAULT))
              ((EQ Direction 'out)
               (OPEN Path :DIRECTION :OUTPUT
                          :ELEMENT-TYPE :DEFAULT
                          :IF-EXISTS :SUPERSEDE))
              (T (ERROR "invalid direction"))))
  
  (DEFUN type (X MyType) (DECLARE (IGNORE MyType)) X)
  
  
negative.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))
  
  (DEFUN number? (N)
    (IF (NUMBERP N) '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 SHEN-TOPLEVEL ()
    (HANDLER-CASE (shen.shen)
      (SB-SYS:INTERACTIVE-INTERRUPT ()
        (FORMAT T "~%Quit.~%")
        (exit 0))))
  