anchor.diff:  
   (DECLAIM (INLINE read-byte))
   
  -(DEFUN read-byte (S)
  -  (READ-BYTE S NIL -1))
  -
  -;(DEFUN eos? (Stream)
  - ;  (IF (LISTEN Stream) 'false 'true))
  +(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))
  -          ;  ((EQ Direction 'out)
  -           ;  (OPEN Path :DIRECTION :OUTPUT
  -            ;            :ELEMENT-TYPE 'UNSIGNED-BYTE
  -              ;          :IF-EXISTS :SUPERSEDE))
  -           ; (T (ERROR "invalid 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 :DEFAULT))
  -            ((EQ Direction 'out)
  -             (OPEN Path :DIRECTION :OUTPUT
  -                        :ELEMENT-TYPE :DEFAULT
  -                        :IF-EXISTS :SUPERSEDE))
  -            (T (ERROR "invalid 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)
   
  
positive.code: (DEFUN string->n (S) (CHAR-CODE (CAR (COERCE S 'LIST))))
  
  (DEFUN str (X)
    (COND ((NULL X) (ERROR "[] is not an atom in Shen; str cannot convert it to a string.~%"))
          ((SYMBOLP X)
           (shen.process-string (SYMBOL-NAME X)))
          ((NUMBERP X)
           (shen.process-number (FORMAT NIL "~A" X)))
          ((STRINGP X) (FORMAT NIL "~S" X))
          ((STREAMP X) (FORMAT NIL "~A" X))
          ((FUNCTIONP X) (FORMAT NIL "~A" X))
          (T (ERROR "~S is not an atom, stream or closure; str cannot convert it to a string.~%" X))))
  
  (DEFUN shen.process-number (S)
    (COND ((STRING-EQUAL S "") "")
          ((STRING-EQUAL (pos S 0) "d")
           (IF (STRING-EQUAL (pos S 1) "0")
               ""
               (cn "e" (tlstr S))))
          (T (cn (pos S 0) (shen.process-number (tlstr S))))))
  
  (DEFUN shen.process-string (X)
     (COND ((STRING-EQUAL X "") X)
           ((AND (> (LENGTH X) 8)
                 (STRING-EQUAL X "_hash1957" :END1 9))
            (cn "#" (shen.process-string (SUBSEQ X 9))))
  
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))))
  