anchor.diff:  (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 ((EQL #\. (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 ((EQL #\. (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 ((~G930 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G931 (L) (CL:LABELS ((~G932 (S) (CL:LABELS ((~G933 (~G48) (CL:BLOCK NIL (CL:LABELS ((~G934 (X) (CL:TAGBODY ~G49 (CL:COND ((== X ~G48) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G49)))) (~G934 0))))) (~G933 L)))) (~G932 (FUNCALL MAKER L))))) (~G931 (- END START)))))))) (~G930 (CL:LENGTH SEQ)))))))))
  -(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G935 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G936 (L) (CL:LABELS ((~G937 (S) (CL:LABELS ((~G938 (~G44) (CL:BLOCK NIL (CL:LABELS ((~G939 (X) (CL:TAGBODY ~G45 (CL:COND ((== X ~G44) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (STRING-CONCAT S (STRING (ELT SEQ (NUMBER+ START X)))))) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G45)))) (~G939 0))))) (~G938 L)))) (~G937 (CL:MAKE-STRING 0))))) (~G936 (- END START)))))))) (~G935 (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 ((~G940 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G940 START)))) (CL:LABELS ((~G941 (Q) (CL:LABELS ((~G942 (LEN) (CL:LABELS ((~G943 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G47 (CL:COND ((NOT (CL:COND (LST (< 0 LEN)))) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (CL:CAR LST)) (CL:PROGN (CL:SETQ LEN (- LEN 1))) (CL:PROGN (CL:SETQ LST (CL:CDR LST))) (CL:GO ~G47)))))) (~G943 (CL:NTHCDR START SEQ))))) (~G942 (- END START))))) (~G941 (MAKE-QUEUE)))))))))
  +(CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G930 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G931 (L) (CL:LABELS ((~G932 (S) (CL:LABELS ((~G933 (~G41) (CL:BLOCK NIL (CL:LABELS ((~G934 (X) (CL:TAGBODY ~G42 (CL:COND ((== X ~G41) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G42)))) (~G934 0))))) (~G933 L)))) (~G932 (FUNCALL MAKER L))))) (~G931 (- END START)))))))) (~G930 (CL:LENGTH SEQ)))))))))
  +(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G935 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G936 (L) (CL:LABELS ((~G937 (S) (CL:LABELS ((~G938 (~G37) (CL:BLOCK NIL (CL:LABELS ((~G939 (X) (CL:TAGBODY ~G38 (CL:COND ((== X ~G37) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (STRING-CONCAT S (STRING (ELT SEQ (NUMBER+ START X)))))) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G38)))) (~G939 0))))) (~G938 L)))) (~G937 (CL:MAKE-STRING 0))))) (~G936 (- END START)))))))) (~G935 (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 ((~G940 (~G39) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G39)))) (~G940 START)))) (CL:LABELS ((~G941 (Q) (CL:LABELS ((~G942 (LEN) (CL:LABELS ((~G943 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G40 (CL:COND ((NOT (CL:COND (LST (< 0 LEN)))) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (CL:CAR LST)) (CL:PROGN (CL:SETQ LEN (- LEN 1))) (CL:PROGN (CL:SETQ LST (CL:CDR LST))) (CL:GO ~G40)))))) (~G943 (CL:NTHCDR START SEQ))))) (~G942 (- END START))))) (~G941 (MAKE-QUEUE)))))))))
   (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)))))))
   (CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  
positive.code: (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1046 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1046 (CL:APPLY *MACROCALL* (CL:LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN LIST? (X) (CL:COND ((CONS? X) T) (T (NOT X))))
  (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1047 (~G115) (CL:LABELS ((~G1048 (I) (CL:TAGBODY ~G113 (CL:COND ((NOT ~G115) (CL:GO ~G114))) (CL:SETQ I (CL:CAR ~G115)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G115 (CL:CDR ~G115)) (CL:GO ~G113) ~G114 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1048 NIL)))) (~G1047 LST))))))))
  (CL:DEFUN CLOSE (STR) (CL:BLOCK CLOSE (CL:BLOCK NIL (%FCLOSE (STREAM-HANDLE STR)))))
  (CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1049 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1049 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  (CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X)))) (T X)))))
  (CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (CL:COND ((SEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1050 (~G226) (CL:COND (~G226 ~G226) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1050 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1051 (~G310) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1052 (~G311) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G310)) ~G311)) (~G1052 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1051 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1053 (~G634) (CL:COND ((CL:ATOM ~G634) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G634) (QQ _)) ((QUASIQUOTE-SPLICE? ~G634) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1053 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1054 (~G635) (CL:COND ((QUOTE? ~G635) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G635) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1054 _)))) (WALK (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (DISP _)) (T (CL:CONS (WALK (DISP (CL:CAR _))) (WALK (CL:CDR _)))))))) (CL:CAR (WALK (CL:LIST X)))))))
  (CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((EQL _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1055 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1055 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  
negative.code: (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G864 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G864 (PEEK-CHAR STR))))))
  (CL:DEFUN READ-INTEGER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-INTEGER (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (INTEGER (READ-INTEGER-0 STR 0)))))))
  (CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:COND ((> (CL:CHAR-CODE X) 32) (NOT (SPECIAL-CHAR? X)))))))))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G865 (~G63) (CL:COND (~G63 ~G63) (T (CL:LABELS ((~G866 (~G64) (CL:COND (~G64 ~G64) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G866 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G865 (DIGIT-CHAR? X))))))
  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CODE-CHAR (- (+ (CL:CHAR-CODE C) (CL:CHAR-CODE #\A)) (CL:CHAR-CODE #\a)))) (T C)))))
  (CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (GENERIC-SPLIT OBJ SEQ :TEST TEST :INCLUDE? INCLUDE?))))
  (CL:DEFUN STREAM-LOCATION-ID (ARR) (CL:BLOCK STREAM-LOCATION-ID (CL:BLOCK NIL (CL:AREF ARR 3))))
  (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:BLOCK 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 ((~G867 (~G90) (CL:LABELS ((~G868 (SEQ) (CL:TAGBODY ~G88 (CL:COND ((NOT ~G90) (CL:GO ~G89))) (CL:SETQ SEQ (CL:CAR ~G90)) (CL:LABELS ((~G869 (~G91) (CL:BLOCK NIL (CL:LABELS ((~G870 (!) (CL:TAGBODY ~G92 (CL:COND ((== ! ~G91) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G871 (~G87) (CL:COND (~G87 ~G87) (T (CL:RETURN-FROM EVERY NIL))))) (~G871 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G92)))) (~G870 0))))) (~G869 (CL:LENGTH SEQ))) (CL:SETQ ~G90 (CL:CDR ~G90)) (CL:GO ~G88) ~G89 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G868 NIL)))) (~G867 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G872 (~G62) (CL:COND (~G62 ~G62) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G872 (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))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G873 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G874 (~G134) (CL:COND (~G134 (CL:PROGN (CL:LABELS ((~G875 (~G136) (CL:BLOCK NIL (CL:LABELS ((~G876 (~G135) (CL:TAGBODY ~G137 (CL:COND ((== ~G135 ~G136) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G877 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G877 (ELT ~G134 ~G135))) (CL:SETQ ~G135 (NUMBER+ 1 ~G135)) (CL:GO ~G137)))) (~G876 0))))) (~G875 (CL:LENGTH ~G134)))))))) (~G874 X))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 (CL:CHAR-CODE X)) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 STREAM-LOCATION)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE STREAM-LOCATION) 1) STREAM-LOCATION)))) (T (CL:COND ((== 9 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G873 STREAM-LOCATION (STREAM-LOCATION-TRACK? STREAM-LOCATION) (STREAM-LOCATION-ID STREAM-LOCATION) (STREAM-LOCATION-LINE STREAM-LOCATION) (STREAM-LOCATION-COLUMN STREAM-LOCATION) (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))))
  (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  (CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
  (CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
  (CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G878 (~G141) (CL:LABELS ((~G879 (!) (CL:TAGBODY ~G139 (CL:COND ((NOT ~G141) (CL:GO ~G140))) (CL:SETQ ! (CL:CAR ~G141)) (STREAM-PRINC ! STR) (CL:SETQ ~G141 (CL:CDR ~G141)) (CL:GO ~G139) ~G140 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G879 NIL)))) (~G878 X)))) ((CL:LABELS ((~G880 (~G138) (CL:COND (~G138 ~G138) (T (CHARACTER? X))))) (~G880 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (FUNCALL (STREAM-FUN-OUT STR) X STR))))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
  (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
  (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G250 (CL:COND ((NOT (NOT (CL:COND ((EQL #\| (READ-CHAR STR)) (EQL #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) (CL:GO ~G250)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G881 (~G251) (CL:COND (~G251 ~G251) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G881 (CL:COND ((CL:CDR X) (CL:LABELS ((~G882 (~G252) (CL:COND (~G252 ~G252) (T (EQL #\. (CL:CAR X)))))) (~G882 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G883 (~G253) (CL:COND (~G253 ~G253) (T (EQL #\. _))))) (~G883 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN READ-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK READ-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (CL:LABELS ((~G884 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G885 (~G249) (CL:COND (~G249 ~G249) (T *KEYWORD-PACKAGE*)))) (~G885 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G884 (READ-SYMBOL STR))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND ((NOT X) NIL) ((CL:CDR X) (CL:CONS 'CL:SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X)) "TRE") NIL)) NIL)))) ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((ERR (_) (CL:BLOCK NIL (CL:LABELS ((~G886 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G886 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G887 (~G262) (CL:COND ((EQL ~G262 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G262 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G262 :CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G887 TOKEN)) (CL:LABELS ((~G888 (!) (CL:COND (! (CL:LABELS ((~G889 (~G264) (CL:LABELS ((~G890 (~G265) (CL:LABELS ((~G891 (TOKEN) (CL:LABELS ((~G892 (~G266) (CL:LABELS ((~G893 (PKG) (CL:LABELS ((~G894 (~G267) (CL:LABELS ((~G895 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G896 (X) (CL:LABELS ((~G897 (~G269) (CL:LABELS ((~G898 (~G270) (CL:LABELS ((~G899 (TOKEN) (CL:LABELS ((~G900 (~G271) (CL:LABELS ((~G901 (PKG) (CL:LABELS ((~G902 (~G272) (CL:LABELS ((~G903 (SYM) (CL:LABELS ((~G904 (~G263) (CL:COND (~G263 ~G263) (T (ERR "Only one value allowed after dotted cons"))))) (~G904 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G903 (CL:CAR ~G272))))) (~G902 (CL:CDR ~G271))))) (~G901 (CL:CAR ~G271))))) (~G900 (CL:CDR ~G270))))) (~G899 (CL:CAR ~G270))))) (~G898 (CL:CDR ~G269))))) (~G897 (READ-TOKEN STR))))) (~G896 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G895 (CL:CAR ~G267))))) (~G894 (CL:CDR ~G266))))) (~G893 (CL:CAR ~G266))))) (~G892 (CL:CDR ~G265))))) (~G891 (CL:CAR ~G265))))) (~G890 (CL:CDR ~G264))))) (~G889 !))) (T (ERR "Closing bracket missing"))))) (~G888 (READ-TOKEN STR))))))))) (CL:LABELS ((~G905 (~G274) (CL:LABELS ((~G906 (~G275) (CL:LABELS ((~G907 (TOKEN) (CL:LABELS ((~G908 (~G276) (CL:LABELS ((~G909 (PKG) (CL:LABELS ((~G910 (~G277) (CL:LABELS ((~G911 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G911 (CL:CAR ~G277))))) (~G910 (CL:CDR ~G276))))) (~G909 (CL:CAR ~G276))))) (~G908 (CL:CDR ~G275))))) (~G907 (CL:CAR ~G275))))) (~G906 (CL:CDR ~G274))))) (~G905 (READ-TOKEN STR)))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G912 (~G234) (CL:COND (~G234 ~G234) (T (CL:LABELS ((~G913 (~G235) (CL:COND (~G235 ~G235) (T (EQL X :CURLY-BRACKET-CLOSE))))) (~G913 (EQL X :SQUARE-BRACKET-CLOSE))))))) (~G912 (EQL X :BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G914 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL SYM PKG))))) (~G914 (SPLIT #\. SYM))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G915 (!) (CL:COND (! (CL:PROGN (READ-CHAR STR) (REC (NUMBER+ (* V 16) (- (CL:CHAR-CODE !) (CL:COND ((DIGIT-CHAR? !) (CL:CHAR-CODE #\0)) (T (- (CL:CHAR-CODE #\A) 10)))))))) (T V)))) (~G915 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G916 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G916 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G917 (~G220) (CL:COND (~G220 ~G220) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G917 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G918 (~G221) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G221)) (~G918 (REC 0)))))))
  (CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((EQL #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G919 (~G222) (CL:COND (~G222 ~G222) (T 0)))) (~G919 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  (CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G920 (~G157) (CL:LABELS ((~G921 (S) (CL:LABELS ((~G922 (~G158) (CL:COND (~G157 ~G158) (T (GET-STREAM-STRING S))))) (~G922 (CL:PROGN (CL:COND ((NUMBER-NOT-CHARACTER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S)) (T (STREAM-PRINC X S))) X))))) (~G921 (DEFAULT-STREAM ~G157))))) (~G920 STR)))))
  (CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (STR) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (CL:COND ((STRING? X) (CL:LABELS ((~G923 (~G144) (CL:COND (~G144 (CL:PROGN (CL:LABELS ((~G924 (~G146) (CL:BLOCK NIL (CL:LABELS ((~G925 (~G145) (CL:TAGBODY ~G147 (CL:COND ((== ~G145 ~G146) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G926 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G926 (ELT ~G144 ~G145))) (CL:SETQ ~G145 (NUMBER+ 1 ~G145)) (CL:GO ~G147)))) (~G925 0))))) (~G924 (CL:LENGTH ~G144)))))))) (~G923 X))) (T (ENQUEUE (STREAM-USER-DETAIL STR) X)))) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
  (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:BLOCK NIL (CL:LABELS ((~G927 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G927 (READ-CHAR STR)))))) (LIST-STRING (F))))))
  (CL:DEFUN READ-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-CHAR (CL:BLOCK NIL (%TRACK-LOCATION (STREAM-INPUT-LOCATION STR) (READ-CHAR-0 STR)))))
  (CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((CHARACTER? X) (CL:COND ((< (CL:CHAR-CODE X) 33) (>= (CL:CHAR-CODE X) 0))))))))
  