anchor.diff:  (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)))))))
   (CL:DEFUN ARGUMENT-NAME? (X) (CL:BLOCK ARGUMENT-NAME? (CL:BLOCK NIL (CL:ATOM X))))
  -(CL:DEFUN $ (CL:&REST ARGS) (CL:BLOCK $ (CL:BLOCK NIL (MAKE-SYMBOL (CL:APPLY (CL:FUNCTION +) (CL:MAPCAR (CL:FUNCTION STRING) ARGS))))))
  +(CL:DEFUN $ (CL:&REST ARGS) (CL:BLOCK $ (CL:BLOCK NIL (MAKE-SYMBOL (CL:APPLY (CL:FUNCTION +) (DYNAMIC-MAP (CL:FUNCTION STRING) ARGS))))))
   (CL:DEFUN ARGDEF-GET-VALUE (DEFS VALS) (CL:BLOCK ARGDEF-GET-VALUE (CL:BLOCK NIL (CL:COND ((CONS? VALS) (CL:CAR VALS)) ((CONS? (CL:CAR DEFS)) (CADR (CL:CAR DEFS))) (T (CL:CAR DEFS))))))
   (CL:DEFUN ARGUMENT-KEYWORD? (X) (CL:BLOCK ARGUMENT-KEYWORD? (CL:BLOCK NIL (CL:LABELS ((~G989 (~G167) (CL:COND (~G167 ~G167) (T (CL:LABELS ((~G990 (~G168) (CL:COND (~G168 ~G168) (T (CL:LABELS ((~G991 (~G169) (CL:COND (~G169 ~G169) (T (EQL X 'CL:&KEY))))) (~G991 (EQL X 'CL:&OPTIONAL))))))) (~G990 (EQL X 'CL:&BODY))))))) (~G989 (EQL X 'CL:&REST))))))
   (CL:DEFUN ARGDEF-GET-NAME (X) (CL:BLOCK ARGDEF-GET-NAME (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:CAR X)) (T X)))))
   (CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G992 (KEYS) (CL:LABELS ((MAKE-&KEY-DESCR (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR _)) (COPY-DEF-UNTIL-&KEY _)) (T (CL:LABELS ((~G993 (!) (CL:PROGN (CL:SETQ KEYS (CL:CONS (CL:COND ((CONS? !) (CL:CONS (CL:CAR !) (CL:CAR (CL:CDR !)))) (T (CL:CONS ! !))) KEYS))) (MAKE-&KEY-DESCR (CL:CDR _)))) (~G993 (CL:CAR _)))))))))) (COPY-DEF-UNTIL-&KEY (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((EQ 'CL:&KEY (CL:CAR _)) (MAKE-&KEY-DESCR (CL:CDR _))) (T (CL:CONS (CL:CAR _) (COPY-DEF-UNTIL-&KEY (CL:CDR _))))))))))) (VALUES (COPY-DEF-UNTIL-&KEY DEF) (REVERSE KEYS))))) (~G992 NIL)))))
   (CL:DEFVAR *VALUES-MAGIC*)
  -(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G994 (~G8) (CL:COND (~G8 ~G8) (T X)))) (~G994 (CL:CAR X))) VALS))) VALS)))
   (CL:DEFUN COPY-HEAD (X SIZE) (CL:BLOCK COPY-HEAD (CL:BLOCK NIL (CL:COND ((CL:COND (X (< 0 SIZE))) (CL:CONS (CL:CAR X) (COPY-HEAD (CL:CDR X) (-- SIZE))))))))
  +(CL:DEFUN CARLIST (~G106) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G106))))
  +(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G994 (~G173) (CL:LABELS ((~G995 (~G174) (CL:LABELS ((~G996 (A) (CL:LABELS ((~G997 (~G175) (CL:LABELS ((~G998 (K) (CL:LABELS ((~G999 (ARGDEFS) (CL:LABELS ((~G1000 (KEY-ARGS) (CL:LABELS ((~G1001 (NUM) (CL:LABELS ((~G1002 (NO-STATIC) (CL:LABELS ((~G1003 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~L; In argument expansion for ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL." (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1004 (K) (CL:COND (K (CL:LABELS ((~G1005 (!) (CL:LABELS ((~G1006 (~G172) (CL:COND (~G172 ~G172) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (CL:LIST (CL:CAR !)))))))) (~G1006 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1005 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1004 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1007 (~G170) (CL:COND ((EQ ~G170 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G170 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G170 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1007 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "Too many arguments. Maximum is ~A, but ~A more given." (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1008 (~G171) (CL:COND (~G171 ~G171) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1008 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1009 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (DYNAMIC-MAP (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G1009 (EXP-MAIN ARGDEFS ALST)))))) (~G1003 NIL)))) (~G1002 NIL)))) (~G1001 0)))) (~G1000 K)))) (~G999 A)))) (~G998 (CL:CAR ~G175))))) (~G997 (CL:CDR ~G174))))) (~G996 (CL:CAR ~G174))))) (~G995 (CL:CDR ~G173))))) (~G994 (MAKE-&KEY-ALIST ADEF))))))
  +(CL:DEFUN %KEY? (X) (CL:BLOCK %KEY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%KEY (CL:CAR X)) X)))))))
  +(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1010 (~G164) (CL:COND (~G164 ~G164) (T (%BODY? X))))) (~G1010 (%REST? X))))))
  +(CL:DEFUN ++ (X) (NUMBER+ X 1))
  +(CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING X)))))
  +(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1011 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G1011 START)))) (CL:LABELS ((~G1012 (~G47) (CL:COND ((CONS? ~G47) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G47) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G47) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1012 SEQ))))))))
  +(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1013 (~G96) (CL:LABELS ((~G1014 (~G97) (CL:LABELS ((~G1015 (NUM-CDRS) (CL:LABELS ((~G1016 (~G98) (CL:LABELS ((~G1017 (WITHOUT-START) (CL:LABELS ((~G1018 (~G100) (CL:LABELS ((~G1019 (~G101) (CL:LABELS ((~G1020 (NUM-CARS) (CL:LABELS ((~G1021 (~G102) (CL:LABELS ((~G1022 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1022 (CL:CAR ~G102))))) (~G1021 (CL:CDR ~G101))))) (~G1020 (CL:CAR ~G101))))) (~G1019 (CL:CDR ~G100))))) (~G1018 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1017 (CL:CAR ~G98))))) (~G1016 (CL:CDR ~G97))))) (~G1015 (CL:CAR ~G97))))) (~G1014 (CL:CDR ~G96))))) (~G1013 (DOT-EXPAND-HEAD-LENGTH X))))))
  +(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1023 (SL) (CL:LABELS ((~G1024 (~G105) (CL:COND (~G105 ~G105) (T (EQL #\. (CL:CAR (CL:LAST SL))))))) (~G1024 (EQL #\. (CL:CAR SL)))))) (~G1023 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1025 (SL) (CL:LABELS ((~G1026 (L) (CL:LABELS ((~G1027 (P) (CL:LABELS ((~G1028 (~G104) (CL:COND (~G104 ~G104) (T (NOT P))))) (~G1028 (== 1 L))))) (~G1027 (DOT-POSITION SL))))) (~G1026 (CL:LENGTH SL))))) (~G1025 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION CHARACTER==)))))
  +(CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((EQL #\; (PEEK-CHAR STR)) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR)))))))
  +(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1029 (~G260) (CL:COND ((EQ ~G260 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G260 :CHAR) (READ-CHAR STR)) ((EQ ~G260 :NUMBER) (CL:LABELS ((~G1030 (S) (PRINC SYM S) (READ-NUMBER S))) (~G1030 (MAKE-STRING-STREAM)))) ((EQ ~G260 :HEXNUM) (READ-HEX STR)) ((EQ ~G260 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G260 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G1031 (~G261) (CL:COND ((EQL ~G261 :BRACKET-CLOSE) "round") ((EQL ~G261 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G261 :SQUARE-BRACKET-CLOSE) "square")))) (~G1031 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G1029 TOKEN)))))
  +(CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST (MAKE-SYMBOL (SYMBOL-NAME TOKEN)) (READ-EXPR STR)))))
  +(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1032 (~G230) (CL:COND (~G230 ~G230) (T (CL:LABELS ((~G1033 (~G231) (CL:COND (~G231 ~G231) (T (CL:LABELS ((~G1034 (~G232) (CL:COND (~G232 ~G232) (T (CL:LABELS ((~G1035 (~G233) (CL:COND (~G233 ~G233) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G1035 (EQL X :QUASIQUOTE-SPLICE))))))) (~G1034 (EQL X :QUASIQUOTE))))))) (~G1033 (EQL X :BACKQUOTE))))))) (~G1032 (EQL X :QUOTE))))))
  +(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1036 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1037 (~G279) (CL:LABELS ((~G1038 (~G280) (CL:LABELS ((~G1039 (TOKEN) (CL:LABELS ((~G1040 (~G281) (CL:LABELS ((~G1041 (PKG) (CL:LABELS ((~G1042 (~G282) (CL:LABELS ((~G1043 (SYM) (READ-SLOT-VALUE (CL:LIST ! SYM)))) (~G1043 (CL:CAR ~G282))))) (~G1042 (CL:CDR ~G281))))) (~G1041 (CL:CAR ~G281))))) (~G1040 (CL:CDR ~G280))))) (~G1039 (CL:CAR ~G280))))) (~G1038 (CL:CDR ~G279))))) (~G1037 (READ-TOKEN STR))))) (T !)))) (~G1036 (READ-CONS STR))))))
  +(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1044 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1045 (~G256) (CL:LABELS ((~G1046 (~G257) (CL:LABELS ((~G1047 (PKG) (CL:LABELS ((~G1048 (~G258) (CL:LABELS ((~G1049 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (EQL #\. (CL:CAR SYM)))))) :DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) :NUMBER) (T :SYMBOL))) (T (CL:LABELS ((~G1050 (~G254) (CL:COND ((EQL ~G254 #\() :BRACKET-OPEN) ((EQL ~G254 #\)) :BRACKET-CLOSE) ((EQL ~G254 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G254 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G254 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G254 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G254 #\') :QUOTE) ((EQL ~G254 #\`) :BACKQUOTE) ((EQL ~G254 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G254 #\") :DBLQUOTE) ((EQL ~G254 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G254 #\#) (CL:LABELS ((~G1051 (~G255) (CL:COND ((EQL ~G255 #\\) :CHAR) ((EQL ~G255 #\x) :HEXNUM) ((EQL ~G255 #\') :FUNCTION) ((EQL ~G255 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1051 (READ-CHAR STR)))) ((EQL ~G254 -1) :EOF)))) (~G1050 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1049 (CL:CAR ~G258))))) (~G1048 (CL:CDR ~G257))))) (~G1047 (CL:CAR ~G257))))) (~G1046 (CL:CDR ~G256))))) (~G1045 !))))))) (~G1044 (READ-SYMBOL-AND-PACKAGE STR))))))
  +(CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  +(CL:DEFUN STREAM-FUN-IN (ARR) (CL:BLOCK STREAM-FUN-IN (CL:BLOCK NIL (CL:AREF ARR 3))))
  +(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1052 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1052 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1053 (~G160) (CL:LABELS ((~G1054 (S) (CL:LABELS ((~G1055 (~G161) (CL:COND (~G160 ~G161) (T (GET-STREAM-STRING S))))) (~G1055 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1054 (DEFAULT-STREAM ~G160))))) (~G1053 STR)))))
  +(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1056 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1056 (STREAM-OUTPUT-LOCATION STR))))))
  +(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1057 (~G149) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G149)) (~G1057 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  +(CL:DEFUN %FORMAT (INF TXT ARGS) (CL:BLOCK %FORMAT (CL:BLOCK NIL (CL:COND (TXT (CL:PROGN (CL:LABELS ((~G1058 (!) (CL:COND ((EQL (CL:CAR TXT) #\\) (CL:PROGN (PRINC (CL:CAR TXT) !) (PRINC (CL:CAR (CL:CDR TXT)) !) (%FORMAT INF (CL:CDR (CL:CDR TXT)) ARGS))) ((EQL (CL:CAR TXT) #\~) (%FORMAT-DIRECTIVE INF (CL:CDR TXT) ARGS)) (T (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS)))))) (~G1058 (FORMAT-INFO-STREAM INF)))))))))
  +(CL:DEFUN MAKE-FORMAT-INFO (CL:&KEY (STREAM 'STREAM) (TEXT 'TEXT) (ARGS 'ARGS) (PROCESSED-ARGS 'PROCESSED-ARGS)) (CL:BLOCK MAKE-FORMAT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1059 (~G301) (CL:PROGN (=-AREF 'STRUCT ~G301 0) (=-AREF 'FORMAT-INFO ~G301 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G301 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G301 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G301 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G301 5)) ~G301)) (~G1059 (MAKE-ARRAY 6))))))
  +(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1060 (~G143) (CL:COND ((EQL ~G143 NIL) (MAKE-STRING-STREAM)) ((EQL ~G143 T) *STANDARD-OUTPUT*) (T X)))) (~G1060 X)))))
  +(CL:DEFUN -- (X) (NUMBER- X 1))
  +(CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
  +(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1061 (~G8) (CL:COND (~G8 ~G8) (T X)))) (~G1061 (CL:CAR X))) VALS))) VALS)))
   (CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
   (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  -(CL:DEFUN CARLIST (~G106) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G106))))
  -(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G995 (~G173) (CL:LABELS ((~G996 (~G174) (CL:LABELS ((~G997 (A) (CL:LABELS ((~G998 (~G175) (CL:LABELS ((~G999 (K) (CL:LABELS ((~G1000 (ARGDEFS) (CL:LABELS ((~G1001 (KEY-ARGS) (CL:LABELS ((~G1002 (NUM) (CL:LABELS ((~G1003 (NO-STATIC) (CL:LABELS ((~G1004 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~L; In argument expansion for ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL." (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1005 (K) (CL:COND (K (CL:LABELS ((~G1006 (!) (CL:LABELS ((~G1007 (~G172) (CL:COND (~G172 ~G172) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (CL:LIST (CL:CAR !)))))))) (~G1007 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1006 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1005 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1008 (~G170) (CL:COND ((EQ ~G170 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G170 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G170 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1008 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "Too many arguments. Maximum is ~A, but ~A more given." (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1009 (~G171) (CL:COND (~G171 ~G171) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1009 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1010 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G1010 (EXP-MAIN ARGDEFS ALST)))))) (~G1004 NIL)))) (~G1003 NIL)))) (~G1002 0)))) (~G1001 K)))) (~G1000 A)))) (~G999 (CL:CAR ~G175))))) (~G998 (CL:CDR ~G174))))) (~G997 (CL:CAR ~G174))))) (~G996 (CL:CDR ~G173))))) (~G995 (MAKE-&KEY-ALIST ADEF))))))
  -(CL:DEFUN %KEY? (X) (CL:BLOCK %KEY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%KEY (CL:CAR X)) X)))))))
  -(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1011 (~G164) (CL:COND (~G164 ~G164) (T (%BODY? X))))) (~G1011 (%REST? X))))))
  -(CL:DEFUN ++ (X) (NUMBER+ X 1))
  -(CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING X)))))
  -(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1012 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G1012 START)))) (CL:LABELS ((~G1013 (~G47) (CL:COND ((CONS? ~G47) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G47) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G47) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1013 SEQ))))))))
  -(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1014 (~G96) (CL:LABELS ((~G1015 (~G97) (CL:LABELS ((~G1016 (NUM-CDRS) (CL:LABELS ((~G1017 (~G98) (CL:LABELS ((~G1018 (WITHOUT-START) (CL:LABELS ((~G1019 (~G100) (CL:LABELS ((~G1020 (~G101) (CL:LABELS ((~G1021 (NUM-CARS) (CL:LABELS ((~G1022 (~G102) (CL:LABELS ((~G1023 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1023 (CL:CAR ~G102))))) (~G1022 (CL:CDR ~G101))))) (~G1021 (CL:CAR ~G101))))) (~G1020 (CL:CDR ~G100))))) (~G1019 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1018 (CL:CAR ~G98))))) (~G1017 (CL:CDR ~G97))))) (~G1016 (CL:CAR ~G97))))) (~G1015 (CL:CDR ~G96))))) (~G1014 (DOT-EXPAND-HEAD-LENGTH X))))))
  -(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1024 (SL) (CL:LABELS ((~G1025 (~G105) (CL:COND (~G105 ~G105) (T (EQL #\. (CL:CAR (CL:LAST SL))))))) (~G1025 (EQL #\. (CL:CAR SL)))))) (~G1024 (STRING-LIST (SYMBOL-NAME X)))))))
  -(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1026 (SL) (CL:LABELS ((~G1027 (L) (CL:LABELS ((~G1028 (P) (CL:LABELS ((~G1029 (~G104) (CL:COND (~G104 ~G104) (T (NOT P))))) (~G1029 (== 1 L))))) (~G1028 (DOT-POSITION SL))))) (~G1027 (CL:LENGTH SL))))) (~G1026 (STRING-LIST (SYMBOL-NAME X)))))))
  -(CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION CHARACTER==)))))
  -(CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((EQL #\; (PEEK-CHAR STR)) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR)))))))
  -(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1030 (~G260) (CL:COND ((EQ ~G260 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G260 :CHAR) (READ-CHAR STR)) ((EQ ~G260 :NUMBER) (CL:LABELS ((~G1031 (S) (PRINC SYM S) (READ-NUMBER S))) (~G1031 (MAKE-STRING-STREAM)))) ((EQ ~G260 :HEXNUM) (READ-HEX STR)) ((EQ ~G260 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G260 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G1032 (~G261) (CL:COND ((EQL ~G261 :BRACKET-CLOSE) "round") ((EQL ~G261 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G261 :SQUARE-BRACKET-CLOSE) "square")))) (~G1032 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G1030 TOKEN)))))
  -(CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST (MAKE-SYMBOL (SYMBOL-NAME TOKEN)) (READ-EXPR STR)))))
  -(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1033 (~G230) (CL:COND (~G230 ~G230) (T (CL:LABELS ((~G1034 (~G231) (CL:COND (~G231 ~G231) (T (CL:LABELS ((~G1035 (~G232) (CL:COND (~G232 ~G232) (T (CL:LABELS ((~G1036 (~G233) (CL:COND (~G233 ~G233) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G1036 (EQL X :QUASIQUOTE-SPLICE))))))) (~G1035 (EQL X :QUASIQUOTE))))))) (~G1034 (EQL X :BACKQUOTE))))))) (~G1033 (EQL X :QUOTE))))))
  -(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1037 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1038 (~G279) (CL:LABELS ((~G1039 (~G280) (CL:LABELS ((~G1040 (TOKEN) (CL:LABELS ((~G1041 (~G281) (CL:LABELS ((~G1042 (PKG) (CL:LABELS ((~G1043 (~G282) (CL:LABELS ((~G1044 (SYM) (READ-SLOT-VALUE (CL:LIST ! SYM)))) (~G1044 (CL:CAR ~G282))))) (~G1043 (CL:CDR ~G281))))) (~G1042 (CL:CAR ~G281))))) (~G1041 (CL:CDR ~G280))))) (~G1040 (CL:CAR ~G280))))) (~G1039 (CL:CDR ~G279))))) (~G1038 (READ-TOKEN STR))))) (T !)))) (~G1037 (READ-CONS STR))))))
  -(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1045 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1046 (~G256) (CL:LABELS ((~G1047 (~G257) (CL:LABELS ((~G1048 (PKG) (CL:LABELS ((~G1049 (~G258) (CL:LABELS ((~G1050 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (EQL #\. (CL:CAR SYM)))))) :DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) :NUMBER) (T :SYMBOL))) (T (CL:LABELS ((~G1051 (~G254) (CL:COND ((EQL ~G254 #\() :BRACKET-OPEN) ((EQL ~G254 #\)) :BRACKET-CLOSE) ((EQL ~G254 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G254 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G254 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G254 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G254 #\') :QUOTE) ((EQL ~G254 #\`) :BACKQUOTE) ((EQL ~G254 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G254 #\") :DBLQUOTE) ((EQL ~G254 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G254 #\#) (CL:LABELS ((~G1052 (~G255) (CL:COND ((EQL ~G255 #\\) :CHAR) ((EQL ~G255 #\x) :HEXNUM) ((EQL ~G255 #\') :FUNCTION) ((EQL ~G255 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1052 (READ-CHAR STR)))) ((EQL ~G254 -1) :EOF)))) (~G1051 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1050 (CL:CAR ~G258))))) (~G1049 (CL:CDR ~G257))))) (~G1048 (CL:CAR ~G257))))) (~G1047 (CL:CDR ~G256))))) (~G1046 !))))))) (~G1045 (READ-SYMBOL-AND-PACKAGE STR))))))
  -(CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  -(CL:DEFUN STREAM-FUN-IN (ARR) (CL:BLOCK STREAM-FUN-IN (CL:BLOCK NIL (CL:AREF ARR 3))))
  -(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1053 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1053 (STREAM-PEEKED-CHAR STR))))))
  -(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1054 (~G160) (CL:LABELS ((~G1055 (S) (CL:LABELS ((~G1056 (~G161) (CL:COND (~G160 ~G161) (T (GET-STREAM-STRING S))))) (~G1056 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1055 (DEFAULT-STREAM ~G160))))) (~G1054 STR)))))
  -(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1057 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1057 (STREAM-OUTPUT-LOCATION STR))))))
  -(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1058 (~G149) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G149)) (~G1058 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  -(CL:DEFUN %FORMAT (INF TXT ARGS) (CL:BLOCK %FORMAT (CL:BLOCK NIL (CL:COND (TXT (CL:PROGN (CL:LABELS ((~G1059 (!) (CL:COND ((EQL (CL:CAR TXT) #\\) (CL:PROGN (PRINC (CL:CAR TXT) !) (PRINC (CL:CAR (CL:CDR TXT)) !) (%FORMAT INF (CL:CDR (CL:CDR TXT)) ARGS))) ((EQL (CL:CAR TXT) #\~) (%FORMAT-DIRECTIVE INF (CL:CDR TXT) ARGS)) (T (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS)))))) (~G1059 (FORMAT-INFO-STREAM INF)))))))))
  -(CL:DEFUN MAKE-FORMAT-INFO (CL:&KEY (STREAM 'STREAM) (TEXT 'TEXT) (ARGS 'ARGS) (PROCESSED-ARGS 'PROCESSED-ARGS)) (CL:BLOCK MAKE-FORMAT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1060 (~G301) (CL:PROGN (=-AREF 'STRUCT ~G301 0) (=-AREF 'FORMAT-INFO ~G301 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G301 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G301 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G301 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G301 5)) ~G301)) (~G1060 (MAKE-ARRAY 6))))))
  -(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1061 (~G143) (CL:COND ((EQL ~G143 NIL) (MAKE-STRING-STREAM)) ((EQL ~G143 T) *STANDARD-OUTPUT*) (T X)))) (~G1061 X)))))
  -(CL:DEFUN -- (X) (NUMBER- X 1))
  -(CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
   (CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1062 (~G133) (CL:PROGN (=-AREF 'STRUCT ~G133 0) (=-AREF 'STREAM ~G133 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G133 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G133 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G133 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G133 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G133 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G133 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G133 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G133 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G133 10)) ~G133)) (~G1062 (MAKE-ARRAY 11))))))
   (CL:DEFUN %MACROEXPAND-BACKQUOTE (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND-BACKQUOTE (CL:CAR X)) (%MACROEXPAND-BACKQUOTE (CL:CDR X))))))
   (CL:DEFUN MAKE-STANDARD-STREAM NIL (CL:BLOCK MAKE-STANDARD-STREAM (CL:BLOCK NIL (MAKE-STREAM :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR NIL))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C NIL)) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF NIL)))))))
   (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
  +(CL:DEFUN LIST-ARRAY (X) (CL:BLOCK LIST-ARRAY (CL:BLOCK NIL (CL:LABELS ((~G1063 (A) (CL:LABELS ((~G1064 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1065 (~G123) (CL:LABELS ((~G1066 (I) (CL:TAGBODY ~G121 (CL:COND ((NOT ~G123) (CL:GO ~G122))) (CL:SETQ I (CL:CAR ~G123)) (CL:PROGN (=-AREF I A IDX)) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G123 (CL:CDR ~G123)) (CL:GO ~G121) ~G122 (CL:RETURN-FROM NIL (CL:PROGN A))))) (~G1066 NIL)))) (~G1065 X))))) (~G1064 0)))) (~G1063 (MAKE-ARRAY (CL:LENGTH X)))))))
  +(CL:DEFUN ARRAY-LIST (X) (CL:BLOCK ARRAY-LIST (CL:BLOCK NIL (CL:LABELS ((~G1067 (RESULT) (CL:LABELS ((~G1068 (~G30) (CL:BLOCK NIL (CL:LABELS ((~G1069 (!) (CL:TAGBODY ~G31 (CL:COND ((== ! ~G30) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST RESULT))))) (ENQUEUE RESULT (CL:AREF X !)) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G31)))) (~G1069 0))))) (~G1068 (INTEGER (CL:LENGTH X)))))) (~G1067 (MAKE-QUEUE))))))
   (CL:DEFUN MAPCAN (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAN (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION NCONC) (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC LISTS)))))
  -(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1063 (L) (CL:LABELS ((~G1064 (S) (CL:BLOCK NIL (CL:LABELS ((~G1065 (I) (CL:TAGBODY ~G76 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G76)))) (~G1065 (-- L)))) S)) (~G1064 NIL)))) (~G1063 (CL:LENGTH X))))))
  +(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1070 (L) (CL:LABELS ((~G1071 (S) (CL:BLOCK NIL (CL:LABELS ((~G1072 (I) (CL:TAGBODY ~G76 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G76)))) (~G1072 (-- L)))) S)) (~G1071 NIL)))) (~G1070 (CL:LENGTH X))))))
   (CL:DEFUN BACKQUOTE? (X) (CL:BLOCK BACKQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'BACKQUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN QUOTE? (X) (CL:BLOCK QUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:QUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN QUASIQUOTE-SPLICE? (X) (CL:BLOCK QUASIQUOTE-SPLICE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE-SPLICE (CL:CAR X)) X)))))))
   (CL:DEFUN QUASIQUOTE? (X) (CL:BLOCK QUASIQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN ANY-QUASIQUOTE? (X) (CL:COND ((CONS? X) (CL:COND ((EQ (CL:CAR X) 'QUASIQUOTE) T) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) T)))))
  -(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1066 (~G409) (CL:COND (~G409 ~G409) (T (CL:LABELS ((~G1067 (~G410) (CL:COND (~G410 ~G410) (T (CL:LABELS ((~G1068 (~G411) (CL:COND (~G411 ~G411) (T (CL:LABELS ((~G1069 (~G412) (CL:COND (~G412 ~G412) (T (CL:LABELS ((~G1070 (~G413) (CL:COND (~G413 ~G413) (T (CL:LABELS ((~G1071 (~G414) (CL:COND (~G414 ~G414) (T (HASH-TABLE? X))))) (~G1071 (ARRAY? X))))))) (~G1070 (STRING? X))))))) (~G1069 (CHARACTER? X))))))) (~G1068 (NUMBER? X))))))) (~G1067 (EQ T X))))))) (~G1066 (NOT X))))))
  -(CL:DEFUN FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1072 (~G303) (CL:LABELS ((~G1073 (NSTR) (CL:LABELS ((~G1074 (~G304) (CL:COND (~G303 ~G304) (T (GET-STREAM-STRING NSTR))))) (~G1074 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1073 (DEFAULT-STREAM ~G303))))) (~G1072 STR)))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1075 (~G162) (CL:LABELS ((~G1076 (S) (CL:LABELS ((~G1077 (~G163) (CL:COND (~G162 ~G163) (T (GET-STREAM-STRING S))))) (~G1077 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1076 (DEFAULT-STREAM ~G162))))) (~G1075 STR)))))
  +(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1073 (~G409) (CL:COND (~G409 ~G409) (T (CL:LABELS ((~G1074 (~G410) (CL:COND (~G410 ~G410) (T (CL:LABELS ((~G1075 (~G411) (CL:COND (~G411 ~G411) (T (CL:LABELS ((~G1076 (~G412) (CL:COND (~G412 ~G412) (T (CL:LABELS ((~G1077 (~G413) (CL:COND (~G413 ~G413) (T (CL:LABELS ((~G1078 (~G414) (CL:COND (~G414 ~G414) (T (HASH-TABLE? X))))) (~G1078 (ARRAY? X))))))) (~G1077 (STRING? X))))))) (~G1076 (CHARACTER? X))))))) (~G1075 (NUMBER? X))))))) (~G1074 (EQ T X))))))) (~G1073 (NOT X))))))
  +(CL:DEFUN FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1079 (~G303) (CL:LABELS ((~G1080 (NSTR) (CL:LABELS ((~G1081 (~G304) (CL:COND (~G303 ~G304) (T (GET-STREAM-STRING NSTR))))) (~G1081 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1080 (DEFAULT-STREAM ~G303))))) (~G1079 STR)))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1082 (~G162) (CL:LABELS ((~G1083 (S) (CL:LABELS ((~G1084 (~G163) (CL:COND (~G162 ~G163) (T (GET-STREAM-STRING S))))) (~G1084 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1083 (DEFAULT-STREAM ~G162))))) (~G1082 STR)))))
   (CL:DEFUN =-STREAM-PEEKED-CHAR (VAL ARR) (CL:BLOCK =-STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 7)))))
  -(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1078 (~G218) (CL:COND (~G218 ~G218) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1078 (READ-PEEKED-CHAR STR))))))
  +(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1085 (~G218) (CL:COND (~G218 ~G218) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1085 (READ-PEEKED-CHAR STR))))))
   (CL:DEFUN STREAM-PEEKED-CHAR (ARR) (CL:BLOCK STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:AREF ARR 7))))
  -(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1079 (~G285) (CL:LABELS ((~G1080 (~G286) (CL:LABELS ((~G1081 (TOKEN) (CL:LABELS ((~G1082 (~G287) (CL:LABELS ((~G1083 (PKG) (CL:LABELS ((~G1084 (~G288) (CL:LABELS ((~G1085 (SYM) (CL:LABELS ((~G1086 (~G284) (CL:COND ((EQL ~G284 NIL) NIL) ((EQL ~G284 :EOF) NIL) ((EQL ~G284 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G284 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G284 :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))))))) (~G1086 TOKEN)))) (~G1085 (CL:CAR ~G288))))) (~G1084 (CL:CDR ~G287))))) (~G1083 (CL:CAR ~G287))))) (~G1082 (CL:CDR ~G286))))) (~G1081 (CL:CAR ~G286))))) (~G1080 (CL:CDR ~G285))))) (~G1079 (READ-TOKEN STR))))))
  +(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1086 (~G285) (CL:LABELS ((~G1087 (~G286) (CL:LABELS ((~G1088 (TOKEN) (CL:LABELS ((~G1089 (~G287) (CL:LABELS ((~G1090 (PKG) (CL:LABELS ((~G1091 (~G288) (CL:LABELS ((~G1092 (SYM) (CL:LABELS ((~G1093 (~G284) (CL:COND ((EQL ~G284 NIL) NIL) ((EQL ~G284 :EOF) NIL) ((EQL ~G284 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G284 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G284 :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))))))) (~G1093 TOKEN)))) (~G1092 (CL:CAR ~G288))))) (~G1091 (CL:CDR ~G287))))) (~G1090 (CL:CAR ~G287))))) (~G1089 (CL:CDR ~G286))))) (~G1088 (CL:CAR ~G286))))) (~G1087 (CL:CDR ~G285))))) (~G1086 (READ-TOKEN STR))))))
   (CL:DEFUN SEEK-CHAR (STR) (CL:BLOCK SEEK-CHAR (CL:BLOCK NIL (SKIP-SPACES STR) (PEEK-CHAR STR))))
  -(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1087 (SL) (CL:LABELS ((~G1088 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1088 (DOT-POSITION SL))))) (~G1087 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1094 (SL) (CL:LABELS ((~G1095 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1095 (DOT-POSITION SL))))) (~G1094 (STRING-LIST (SYMBOL-NAME X)))))))
   (CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
   (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION))) (CL:BLOCK MAKE-STREAM-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR (STREAM-HANDLE _)))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C (STREAM-HANDLE STR))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF (STREAM-HANDLE _))))))))
  -(CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1089 (~G132) (CL:PROGN (=-AREF 'STRUCT ~G132 0) (=-AREF 'STREAM-LOCATION ~G132 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G132 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G132 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G132 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G132 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G132 6)) ~G132)) (~G1089 (MAKE-ARRAY 7))))))
  -(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1090 (~G144) (CL:COND ((EQL ~G144 'INPUT) "r") ((EQL ~G144 'OUTPUT) "w") ((EQL ~G144 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1090 DIRECTION)))))
  +(CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1096 (~G132) (CL:PROGN (=-AREF 'STRUCT ~G132 0) (=-AREF 'STREAM-LOCATION ~G132 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G132 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G132 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G132 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G132 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G132 6)) ~G132)) (~G1096 (MAKE-ARRAY 7))))))
  +(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1097 (~G144) (CL:COND ((EQL ~G144 'INPUT) "r") ((EQL ~G144 'OUTPUT) "w") ((EQL ~G144 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1097 DIRECTION)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
   (CL:DEFUN CDRLIST (~G107) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G107))))
  -(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1091 (~G165) (CL:COND (~G165 ~G165) (T (%KEY? X))))) (~G1091 (%REST-OR-%BODY? X))))))
  +(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1098 (~G165) (CL:COND (~G165 ~G165) (T (%KEY? X))))) (~G1098 (%REST-OR-%BODY? X))))))
   (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  -(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1092 (!) (CL:COND ((CL:LABELS ((~G1093 (~G177) (CL:COND (~G177 ~G177) (T (EQ ! 'ERROR))))) (~G1093 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1092 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
  +(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1099 (!) (CL:COND ((CL:LABELS ((~G1100 (~G177) (CL:COND (~G177 ~G177) (T (EQ ! 'ERROR))))) (~G1100 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1099 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
   (CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
  -(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:LABELS ((~G1094 (Q) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G32 (CL:COND ((NOT X) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (COPY-HEAD X SIZE)) (CL:PROGN (CL:SETQ X (CL:NTHCDR SIZE X))) (CL:GO ~G32)))))) (~G1094 (MAKE-QUEUE))))))
  +(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:LABELS ((~G1101 (Q) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G32 (CL:COND ((NOT X) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (COPY-HEAD X SIZE)) (CL:PROGN (CL:SETQ X (CL:NTHCDR SIZE X))) (CL:GO ~G32)))))) (~G1101 (MAKE-QUEUE))))))
   (CL:DEFVAR *STANDARD-OUTPUT*)
   (CL:DEFVAR *GENSYM-COUNTER*)
  -(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1095 (TESTS) (CL:LABELS ((~G1096 (END) (CL:LABELS ((~G1097 (~G708) (CL:COND (~G708 ~G708) (T (ERROR "Body is missing."))))) (~G1097 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END))))) NIL)))) (~G1096 (CL:CAR (CL:LAST TESTS)))))) (~G1095 (GROUP BODY 2))))))
  +(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1102 (TESTS) (CL:LABELS ((~G1103 (END) (CL:LABELS ((~G1104 (~G708) (CL:COND (~G708 ~G708) (T (ERROR "Body is missing."))))) (~G1104 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END))))) NIL)))) (~G1103 (CL:CAR (CL:LAST TESTS)))))) (~G1102 (GROUP BODY 2))))))
   (CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  -(CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1098 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1098 (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 %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1105 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1105 (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 ((~G1099 (~G111) (CL:LABELS ((~G1100 (I) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ I (CL:CAR ~G111)) (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 ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1100 NIL)))) (~G1099 LST))))))))
  +(CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (DYNAMIC-MAP (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 ((~G1106 (~G111) (CL:LABELS ((~G1107 (I) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ I (CL:CAR ~G111)) (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 ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1107 NIL)))) (~G1106 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 ((~G1101 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1101 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  +(CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1108 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1108 (%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 ((~G1102 (~G219) (CL:COND (~G219 ~G219) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1102 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1109 (~G219) (CL:COND (~G219 ~G219) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1109 (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 ((~G1103 (~G305) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1104 (~G306) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G305)) ~G306)) (~G1104 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1103 *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 ((~G1105 (~G641) (CL:COND ((CL:ATOM ~G641) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G641) (QQ _)) ((QUASIQUOTE-SPLICE? ~G641) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1105 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1106 (~G642) (CL:COND ((QUOTE? ~G642) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G642) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1106 _)))) (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 ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1110 (~G305) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1111 (~G306) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G305)) ~G306)) (~G1111 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1110 *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 ((~G1112 (~G641) (CL:COND ((CL:ATOM ~G641) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G641) (QQ _)) ((QUASIQUOTE-SPLICE? ~G641) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1112 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1113 (~G642) (CL:COND ((QUOTE? ~G642) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G642) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1113 _)))) (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 ((~G1107 (~G7) (CL:COND (~G7 ~G7) (T (CL:ATOM Y))))) (~G1107 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  +(CL:DEFUN DYNAMIC-MAP (FUNC CL:&REST LISTS) (CL:BLOCK DYNAMIC-MAP (CL:BLOCK NIL (CL:COND ((STRING? (CL:CAR LISTS)) (LIST-STRING (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC (CL:MAPCAR (CL:FUNCTION STRING-LIST) LISTS)))) ((ARRAY? (CL:CAR LISTS)) (LIST-ARRAY (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC (CL:MAPCAR (CL:FUNCTION ARRAY-LIST) LISTS)))) (T (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC LISTS))))))
  +(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1114 (~G7) (CL:COND (~G7 ~G7) (T (CL:ATOM Y))))) (~G1114 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
   (CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  -(CL:DEFUN GENSYM NIL (CL:LABELS ((~G1108 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1108 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  -(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1109 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1109 (CL:CAR X))))
  -(CL:DEFUN MEMBER (ELM LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK MEMBER (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1110 (I) (CL:TAGBODY ~G10 (CL:COND ((NOT I) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:COND ((FUNCALL TEST ELM (CL:CAR I)) (CL:RETURN-FROM MEMBER I))) (CL:SETQ I (CL:CDR I)) (CL:GO ~G10)))) (~G1110 LST))))))
  +(CL:DEFUN GENSYM NIL (CL:LABELS ((~G1115 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1115 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  +(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1116 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1116 (CL:CAR X))))
  +(CL:DEFUN MEMBER (ELM LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK MEMBER (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1117 (I) (CL:TAGBODY ~G10 (CL:COND ((NOT I) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:COND ((FUNCALL TEST ELM (CL:CAR I)) (CL:RETURN-FROM MEMBER I))) (CL:SETQ I (CL:CDR I)) (CL:GO ~G10)))) (~G1117 LST))))))
   (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
   (CL:DEFUN IDENTITY (X) X)
   (CL:DEFVAR *DEFINITION-PRINTER*)
  
positive.code: (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G869 (~G64) (CL:COND (~G64 ~G64) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G869 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X #\0 #\9))))
  (CL:DEFUN GENERIC-SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK GENERIC-SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G870 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G870 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G871 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G872 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G873 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G874 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G875 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G876 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G877 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G878 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G879 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G880 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G881 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G882 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G883 (~G248) (CL:COND (~G248 ~G248) (T (EQL X #\^))))) (~G883 (EQL X #\#))))))) (~G882 (EQL X #\;))))))) (~G881 (EQL X #\:))))))) (~G880 (EQL X #\,))))))) (~G879 (EQL X #\`))))))) (~G878 (EQL X #\'))))))) (~G877 (EQL X #\"))))))) (~G876 (EQL X #\}))))))) (~G875 (EQL X #\{))))))) (~G874 (EQL X #\]))))))) (~G873 (EQL X #\[))))))) (~G872 (EQL X #\)))))))) (~G871 (EQL X #\())))))
  (CL:DEFUN READ-INTEGER-0 (STR V) (CL:BLOCK READ-INTEGER-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-INTEGER-0 STR (+ (* V 10) (DIGIT-NUMBER (READ-CHAR STR))))) (T V)))))
  (CL:DEFUN PEEK-DIGIT (STR) (CL:BLOCK PEEK-DIGIT (CL:BLOCK NIL (CL:LABELS ((~G884 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G884 (PEEK-CHAR STR))))))
  
negative.code: (CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G785 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G785 (GENSYM))))
  (CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G786 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G786 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  (CL:DEFUN LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (CL:ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
  (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((CL:ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (DYNAMIC-MAP (CL:FUNCTION MAKE-LAMBDAS) X))))
  (CL:PROGN (CL:DEFUN %ERROR (MSG) (CL:BREAK (NEUTRALIZE-FORMAT-STRING MSG))) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) (CL:FUNCTION %ERROR)))
  (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
  (CL:DEFVAR *EVAL*)
  