anchor.diff:  (CL:DEFUN STREAM-LOCATION-LINE (ARR) (CL:BLOCK STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:AREF ARR 4))))
   (CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
   (CL:DEFUN READ-SYMBOL (STR) (CL:BLOCK READ-SYMBOL (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (F)))))) (CL:COND ((NOT (SPECIAL-CHAR? (SEEK-CHAR STR))) (CL:PROGN (F))))))))
  -(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1591 (~G111) (CL:LABELS ((~G1592 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1593 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "Negative number of iterations: ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1594 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1595 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1595 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1594 0))))) (~G1593 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1592 NIL)))) (~G1591 SEQS))))))
  +(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1591 (~G111) (CL:LABELS ((~G1592 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1593 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "DOTIMES: Number of iterations is negative. It's ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1594 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1595 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1595 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1594 0))))) (~G1593 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1592 NIL)))) (~G1591 SEQS))))))
   (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1596 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1596 (DECIMAL-DIGIT? C))))))))
   (CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
   (CL:DEFUN STREAM-FUN-OUT (ARR) (CL:BLOCK STREAM-FUN-OUT (CL:BLOCK NIL (CL:AREF ARR 4))))
  
positive.code: (CL:DEFUN DOT-EXPAND-MAKE-EXPR (WHICH NUM X) (CL:BLOCK DOT-EXPAND-MAKE-EXPR (CL:BLOCK NIL (CL:COND ((< 0 NUM) (CL:CONS WHICH (CL:CONS (DOT-EXPAND-MAKE-EXPR WHICH (-- NUM) X) NIL))) (T X)))))
  (CL:DEFUN DOT-EXPAND-TAIL-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-TAIL-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR (CL:LAST X))) (DOT-EXPAND-TAIL-LENGTH (BUTLAST X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN DOT-EXPAND-HEAD-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-HEAD-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1559 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1560 (L) (CL:LABELS ((~G1561 (S) (CL:LABELS ((~G1562 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1563 (X) (CL:TAGBODY ~G63 (CL:COND ((INTEGER== X ~G62) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G63)))) (~G1563 0))))) (~G1562 (INTEGER L))))) (~G1561 (FUNCALL MAKER L))))) (~G1560 (- END START)))))))) (~G1559 (CL:LENGTH SEQ)))))))))
  (CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1564 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1565 (L) (CL:LABELS ((~G1566 (S) (CL:LABELS ((~G1567 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1568 (X) (CL:TAGBODY ~G60 (CL:COND ((INTEGER== X ~G59) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (+ S (STRING (ELT SEQ (+ START X)))))) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G60)))) (~G1568 0))))) (~G1567 (INTEGER L))))) (~G1566 (CL:MAKE-STRING 0))))) (~G1565 (- END START)))))))) (~G1564 (CL:LENGTH SEQ))))))))
  (CL:DEFUN LIST-SUBSEQ (SEQ START CL:&OPTIONAL (END 999999)) (CL:BLOCK LIST-SUBSEQ (CL:BLOCK NIL (CL:COND ((CL:COND (SEQ (NOT (== START END)))) (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1569 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1569 START)))) (CL:LABELS ((COPY-NUM (LST LEN) (CL:COND (LST (CL:COND ((< 0 LEN) (CL:CONS (CL:CAR LST) (COPY-NUM (CL:CDR LST) (-- LEN))))))))) (COPY-NUM (CL:NTHCDR START SEQ) (- END START)))))))))
  (CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
  (CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
  
negative.code: (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
  (CL:DEFVAR *EVAL*)
  (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
  (CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1328 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1329 (~G1274) (CL:COND (~G1274 (CL:PROGN (CL:LABELS ((~G1330 (~G1276) (CL:COND ((INTEGER< ~G1276 0) (ERROR "DOTIMES: Number of iterations is negative. It's ~A." ~G1276))) (CL:BLOCK NIL (CL:LABELS ((~G1331 (~G1275) (CL:TAGBODY ~G1277 (CL:COND ((INTEGER== ~G1275 ~G1276) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1332 (I) (%PRINC I !))) (~G1332 (ELT ~G1274 ~G1275))) (CL:SETQ ~G1275 (INTEGER+ 1 ~G1275)) (CL:GO ~G1277)))) (~G1331 0))))) (~G1330 (INTEGER (CL:LENGTH ~G1274))))))))) (~G1329 X))) (T (CL:PRINC X !))))) (~G1328 (CL:LABELS ((~G1333 (~G1273) (CL:COND (~G1273 ~G1273) (T CL:*STANDARD-OUTPUT*)))) (~G1333 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
  (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
  (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
  