anchor.diff:    (INTERN (shen.process-intern String)))
   
   (DEFUN shen.process-intern (S)
  -  (COND ((STRING-EQUAL S "")
  -         S)
  -        ((STRING-EQUAL (pos S 0) "#")
  -         (cn "_hash1957" (shen.process-intern (tlstr S))))
  -        ((STRING-EQUAL (pos S 0) "'")
  -         (cn "_quote1957" (shen.process-intern (tlstr S))))
  -        ((STRING-EQUAL (pos S 0) "`")
  -         (cn "_backquote1957" (shen.process-intern (tlstr S))))
  -        ((STRING-EQUAL (pos S 0) "|")
  -         (cn "bar!1957" (shen.process-intern (tlstr S))))
  -        (T
  -         (cn (pos S 0) (shen.process-intern (tlstr S))))))
  +  (COND
  +    ((STRING-EQUAL S "")          S)
  +    ((STRING-EQUAL (pos S 0) "#") (cn "_hash1957" (shen.process-intern (tlstr S))))
  +    ((STRING-EQUAL (pos S 0) "'") (cn "_quote1957" (shen.process-intern (tlstr S))))
  +    ((STRING-EQUAL (pos S 0) "`") (cn "_backquote1957" (shen.process-intern (tlstr S))))
  +    ((STRING-EQUAL (pos S 0) "|") (cn "bar!1957" (shen.process-intern (tlstr S))))
  +    (T                            (cn (pos S 0) (shen.process-intern (tlstr S))))))
   
   (DEFUN eval-kl (X)
     (LET ((E (EVAL (shen.kl-to-lisp NIL X))))
  
positive.code:   (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))
          ((OR (STREAMP 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))))
          ((AND (> (LENGTH X) 9)
                (STRING-EQUAL X "_quote1957" :END1 10))
           (cn "'" (shen.process-string (SUBSEQ X 10))))
          ((AND (> (LENGTH X) 13)
                (STRING-EQUAL X "_backquote1957" :END1 14))
           (cn "`" (shen.process-string (SUBSEQ X 14))))
          ((AND (> (LENGTH X) 7)
                (STRING-EQUAL X "bar!1957" :END1 8))
           (cn "|" (shen.process-string (SUBSEQ X 8))))
          (T
           (cn (pos X 0) (shen.process-string (tlstr X))))))
  
  (DEFUN get-time (Time)
    (COND ((EQ Time 'run)
           (* 1.0 (/ (GET-INTERNAL-RUN-TIME) INTERNAL-TIME-UNITS-PER-SECOND)))
          ((EQ Time 'unix)
           (- (GET-UNIVERSAL-TIME) 2208988800))
          (T
           (ERROR "get-time does not understand the parameter ~A~%" Time))))
  
  (DEFUN shen.double-precision (X)
    (IF (INTEGERP X) X (COERCE X 'DOUBLE-FLOAT)))
  
negative.code: 
  (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*)))))
  
  (DEFMACRO and (X Y)
    `(if ,X (if ,Y 'true 'false) 'false))
  