anchor.diff:  (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 ((~G885 (~G147) (CL:LABELS ((~G886 (I) (CL:TAGBODY ~G145 (CL:COND ((NOT ~G147) (CL:GO ~G146))) (CL:SETQ I (CL:CAR ~G147)) (STREAM-PRINC I STR) (CL:SETQ ~G147 (CL:CDR ~G147)) (CL:GO ~G145) ~G146 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G886 NIL)))) (~G885 X)))) ((CL:LABELS ((~G887 (~G144) (CL:COND (~G144 ~G144) (T (CHARACTER? X))))) (~G887 (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-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G888 (~G150) (CL:LABELS ((~G889 (I) (CL:TAGBODY ~G148 (CL:COND ((NOT ~G150) (CL:GO ~G149))) (CL:SETQ I (CL:CAR ~G150)) (STREAM-PRINC I STR) (CL:SETQ ~G150 (CL:CDR ~G150)) (CL:GO ~G148) ~G149 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G889 NIL)))) (~G888 X)))) ((CL:LABELS ((~G890 (~G147) (CL:COND (~G147 ~G147) (T (CHARACTER? X))))) (~G890 (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 VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS *VALUES-MAGIC* VALS))))
  -(CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G246 (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 ~G246)))))))
  -(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G888 (~G247) (CL:COND (~G247 ~G247) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G888 (CL:COND ((CL:CDR X) (CL:LABELS ((~G889 (~G248) (CL:COND (~G248 ~G248) (T (EQL #\. (CL:CAR X)))))) (~G889 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G890 (~G249) (CL:COND (~G249 ~G249) (T (EQL #\. _))))) (~G890 (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 ((~G891 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G892 (~G245) (CL:COND (~G245 ~G245) (T *KEYWORD-PACKAGE*)))) (~G892 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G891 (READ-SYMBOL STR))))))
  +(CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G249 (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 ~G249)))))))
  +(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G891 (~G250) (CL:COND (~G250 ~G250) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G891 (CL:COND ((CL:CDR X) (CL:LABELS ((~G892 (~G251) (CL:COND (~G251 ~G251) (T (EQL #\. (CL:CAR X)))))) (~G892 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G893 (~G252) (CL:COND (~G252 ~G252) (T (EQL #\. _))))) (~G893 (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 ((~G894 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G895 (~G248) (CL:COND (~G248 ~G248) (T *KEYWORD-PACKAGE*)))) (~G895 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G894 (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 (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 ((~G893 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G893 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G894 (~G258) (CL:COND ((EQL ~G258 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G258 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G258 :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))))))) (~G894 TOKEN)) (CL:LABELS ((~G895 (!) (CL:COND (! (CL:LABELS ((~G896 (~G260) (CL:LABELS ((~G897 (~G261) (CL:LABELS ((~G898 (TOKEN) (CL:LABELS ((~G899 (~G262) (CL:LABELS ((~G900 (PKG) (CL:LABELS ((~G901 (~G263) (CL:LABELS ((~G902 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G903 (X) (CL:LABELS ((~G904 (~G265) (CL:LABELS ((~G905 (~G266) (CL:LABELS ((~G906 (TOKEN) (CL:LABELS ((~G907 (~G267) (CL:LABELS ((~G908 (PKG) (CL:LABELS ((~G909 (~G268) (CL:LABELS ((~G910 (SYM) (CL:LABELS ((~G911 (~G259) (CL:COND (~G259 ~G259) (T (ERR "Only one value allowed after dotted cons"))))) (~G911 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G910 (CL:CAR ~G268))))) (~G909 (CL:CDR ~G267))))) (~G908 (CL:CAR ~G267))))) (~G907 (CL:CDR ~G266))))) (~G906 (CL:CAR ~G266))))) (~G905 (CL:CDR ~G265))))) (~G904 (READ-TOKEN STR))))) (~G903 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G902 (CL:CAR ~G263))))) (~G901 (CL:CDR ~G262))))) (~G900 (CL:CAR ~G262))))) (~G899 (CL:CDR ~G261))))) (~G898 (CL:CAR ~G261))))) (~G897 (CL:CDR ~G260))))) (~G896 !))) (T (ERR "Closing bracket missing"))))) (~G895 (READ-TOKEN STR))))))))) (CL:LABELS ((~G912 (~G270) (CL:LABELS ((~G913 (~G271) (CL:LABELS ((~G914 (TOKEN) (CL:LABELS ((~G915 (~G272) (CL:LABELS ((~G916 (PKG) (CL:LABELS ((~G917 (~G273) (CL:LABELS ((~G918 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G918 (CL:CAR ~G273))))) (~G917 (CL:CDR ~G272))))) (~G916 (CL:CAR ~G272))))) (~G915 (CL:CDR ~G271))))) (~G914 (CL:CAR ~G271))))) (~G913 (CL:CDR ~G270))))) (~G912 (READ-TOKEN STR)))))))
  -(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G919 (~G230) (CL:COND (~G230 ~G230) (T (CL:LABELS ((~G920 (~G231) (CL:COND (~G231 ~G231) (T (EQL X :CURLY-BRACKET-CLOSE))))) (~G920 (EQL X :SQUARE-BRACKET-CLOSE))))))) (~G919 (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 ((~G921 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL SYM PKG))))) (~G921 (SPLIT #\. SYM))))))
  -(CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G922 (!) (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)))) (~G922 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G923 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G923 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G924 (~G216) (CL:COND (~G216 ~G216) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G924 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G925 (~G217) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G217)) (~G925 (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 ((~G926 (~G218) (CL:COND (~G218 ~G218) (T 0)))) (~G926 (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 ((~G927 (~G157) (CL:LABELS ((~G928 (S) (CL:LABELS ((~G929 (~G158) (CL:COND (~G157 ~G158) (T (GET-STREAM-STRING S))))) (~G929 (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))))) (~G928 (DEFAULT-STREAM ~G157))))) (~G927 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 ((~G930 (~G150) (CL:COND (~G150 (CL:PROGN (CL:LABELS ((~G931 (~G152) (CL:BLOCK NIL (CL:LABELS ((~G932 (~G151) (CL:TAGBODY ~G153 (CL:COND ((== ~G151 ~G152) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G933 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G933 (ELT ~G150 ~G151))) (CL:SETQ ~G151 (NUMBER+ 1 ~G151)) (CL:GO ~G153)))) (~G932 0))))) (~G931 (INTEGER (CL:LENGTH ~G150))))))))) (~G930 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 ((~G934 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G934 (READ-CHAR STR)))))) (LIST-STRING (F))))))
  +(CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((ERR (_) (CL:BLOCK NIL (CL:LABELS ((~G896 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G896 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G897 (~G261) (CL:COND ((EQL ~G261 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G261 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G261 :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))))))) (~G897 TOKEN)) (CL:LABELS ((~G898 (!) (CL:COND (! (CL:LABELS ((~G899 (~G263) (CL:LABELS ((~G900 (~G264) (CL:LABELS ((~G901 (TOKEN) (CL:LABELS ((~G902 (~G265) (CL:LABELS ((~G903 (PKG) (CL:LABELS ((~G904 (~G266) (CL:LABELS ((~G905 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G906 (X) (CL:LABELS ((~G907 (~G268) (CL:LABELS ((~G908 (~G269) (CL:LABELS ((~G909 (TOKEN) (CL:LABELS ((~G910 (~G270) (CL:LABELS ((~G911 (PKG) (CL:LABELS ((~G912 (~G271) (CL:LABELS ((~G913 (SYM) (CL:LABELS ((~G914 (~G262) (CL:COND (~G262 ~G262) (T (ERR "Only one value allowed after dotted cons"))))) (~G914 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G913 (CL:CAR ~G271))))) (~G912 (CL:CDR ~G270))))) (~G911 (CL:CAR ~G270))))) (~G910 (CL:CDR ~G269))))) (~G909 (CL:CAR ~G269))))) (~G908 (CL:CDR ~G268))))) (~G907 (READ-TOKEN STR))))) (~G906 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G905 (CL:CAR ~G266))))) (~G904 (CL:CDR ~G265))))) (~G903 (CL:CAR ~G265))))) (~G902 (CL:CDR ~G264))))) (~G901 (CL:CAR ~G264))))) (~G900 (CL:CDR ~G263))))) (~G899 !))) (T (ERR "Closing bracket missing"))))) (~G898 (READ-TOKEN STR))))))))) (CL:LABELS ((~G915 (~G273) (CL:LABELS ((~G916 (~G274) (CL:LABELS ((~G917 (TOKEN) (CL:LABELS ((~G918 (~G275) (CL:LABELS ((~G919 (PKG) (CL:LABELS ((~G920 (~G276) (CL:LABELS ((~G921 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G921 (CL:CAR ~G276))))) (~G920 (CL:CDR ~G275))))) (~G919 (CL:CAR ~G275))))) (~G918 (CL:CDR ~G274))))) (~G917 (CL:CAR ~G274))))) (~G916 (CL:CDR ~G273))))) (~G915 (READ-TOKEN STR)))))))
  +(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G922 (~G233) (CL:COND (~G233 ~G233) (T (CL:LABELS ((~G923 (~G234) (CL:COND (~G234 ~G234) (T (EQL X :CURLY-BRACKET-CLOSE))))) (~G923 (EQL X :SQUARE-BRACKET-CLOSE))))))) (~G922 (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 ((~G924 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL SYM PKG))))) (~G924 (SPLIT #\. SYM))))))
  +(CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G925 (!) (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)))) (~G925 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G926 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G926 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G927 (~G219) (CL:COND (~G219 ~G219) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G927 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G928 (~G220) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G220)) (~G928 (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 ((~G929 (~G221) (CL:COND (~G221 ~G221) (T 0)))) (~G929 (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 ((~G930 (~G160) (CL:LABELS ((~G931 (S) (CL:LABELS ((~G932 (~G161) (CL:COND (~G160 ~G161) (T (GET-STREAM-STRING S))))) (~G932 (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))))) (~G931 (DEFAULT-STREAM ~G160))))) (~G930 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 ((~G933 (~G153) (CL:COND (~G153 (CL:PROGN (CL:LABELS ((~G934 (~G155) (CL:BLOCK NIL (CL:LABELS ((~G935 (~G154) (CL:TAGBODY ~G156 (CL:COND ((== ~G154 ~G155) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G936 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G936 (ELT ~G153 ~G154))) (CL:SETQ ~G154 (NUMBER+ 1 ~G154)) (CL:GO ~G156)))) (~G935 0))))) (~G934 (INTEGER (CL:LENGTH ~G153))))))))) (~G933 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 ((~G937 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G937 (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))))))))
  -(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G935 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G935 (READ-CHAR STR))))))
  -(CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G936 (!) (FIND-IF (CL:LAMBDA (X I) (CL:COND ((FUNCALL TEST X OBJ) (CL:PROGN (CL:SETQ ! I))))) SEQ :START START :END END :FROM-END FROM-END :WITH-INDEX T) !)) (~G936 NIL)))))
  +(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G938 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G938 (READ-CHAR STR))))))
  +(CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G939 (!) (FIND-IF (CL:LAMBDA (X I) (CL:COND ((FUNCALL TEST X OBJ) (CL:PROGN (CL:SETQ ! I))))) SEQ :START START :END END :FROM-END FROM-END :WITH-INDEX T) !)) (~G939 NIL)))))
   (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 (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 ((~G937 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G938 (L) (CL:LABELS ((~G939 (S) (CL:LABELS ((~G940 (~G49) (CL:BLOCK NIL (CL:LABELS ((~G941 (X) (CL:TAGBODY ~G50 (CL:COND ((== X ~G49) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G50)))) (~G941 0))))) (~G940 (INTEGER L))))) (~G939 (FUNCALL MAKER L))))) (~G938 (- END START)))))))) (~G937 (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 ((~G942 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G943 (L) (CL:LABELS ((~G944 (S) (CL:LABELS ((~G945 (~G45) (CL:BLOCK NIL (CL:LABELS ((~G946 (X) (CL:TAGBODY ~G46 (CL:COND ((== X ~G45) (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 ~G46)))) (~G946 0))))) (~G945 (INTEGER L))))) (~G944 (CL:MAKE-STRING 0))))) (~G943 (- END START)))))))) (~G942 (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 ((~G947 (~G47) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G47)))) (~G947 START)))) (CL:LABELS ((~G948 (Q) (CL:LABELS ((~G949 (LEN) (CL:LABELS ((~G950 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G48 (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 ~G48)))))) (~G950 (NTHCDR START SEQ))))) (~G949 (- END START))))) (~G948 (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 ((~G940 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G941 (L) (CL:LABELS ((~G942 (S) (CL:LABELS ((~G943 (~G52) (CL:BLOCK NIL (CL:LABELS ((~G944 (X) (CL:TAGBODY ~G53 (CL:COND ((== X ~G52) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G53)))) (~G944 0))))) (~G943 (INTEGER L))))) (~G942 (FUNCALL MAKER L))))) (~G941 (- END START)))))))) (~G940 (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 ((~G945 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G946 (L) (CL:LABELS ((~G947 (S) (CL:LABELS ((~G948 (~G48) (CL:BLOCK NIL (CL:LABELS ((~G949 (X) (CL:TAGBODY ~G49 (CL:COND ((== X ~G48) (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 ~G49)))) (~G949 0))))) (~G948 (INTEGER L))))) (~G947 (CL:MAKE-STRING 0))))) (~G946 (- END START)))))))) (~G945 (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 ((~G950 (~G50) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G50)))) (~G950 START)))) (CL:LABELS ((~G951 (Q) (CL:LABELS ((~G952 (LEN) (CL:LABELS ((~G953 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G51 (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 ~G51)))))) (~G953 (NTHCDR START SEQ))))) (~G952 (- END START))))) (~G951 (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)))))))
  -(CL:DEFUN ARGUMENT-NAME? (X) (CL:BLOCK ARGUMENT-NAME? (CL:BLOCK NIL (CL:ATOM X))))
  +(CL:DEFUN ARGUMENT-NAME? (X) (CL:BLOCK ARGUMENT-NAME? (CL:BLOCK NIL (ATOM X))))
   (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:LABELS ((~G951 (~G5) (CL:COND (~G5 ~G5) (T (CL:LABELS ((~G952 (~G6) (CL:COND (~G6 ~G6) (T (CL:LABELS ((~G953 (~G7) (CL:COND (~G7 ~G7) (T (EQ X 'CL:&KEY))))) (~G953 (EQ X 'CL:&OPTIONAL))))))) (~G952 (EQ X 'CL:&BODY))))))) (~G951 (EQ X 'CL:&REST))))
  +(CL:DEFUN ARGUMENT-KEYWORD? (X) (CL:LABELS ((~G954 (~G5) (CL:COND (~G5 ~G5) (T (CL:LABELS ((~G955 (~G6) (CL:COND (~G6 ~G6) (T (CL:LABELS ((~G956 (~G7) (CL:COND (~G7 ~G7) (T (EQ X 'CL:&KEY))))) (~G956 (EQ X 'CL:&OPTIONAL))))))) (~G955 (EQ X 'CL:&BODY))))))) (~G954 (EQ 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 ((~G954 (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 ((~G955 (!) (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 _)))) (~G955 (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))))) (~G954 NIL)))))
  +(CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G957 (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 ((~G958 (!) (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 _)))) (~G958 (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))))) (~G957 NIL)))))
   (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
   (CL:DEFUN NTHCDR (IDX X) (CL:BLOCK NTHCDR (CL:BLOCK NIL (CL:COND (X (CL:COND ((ZERO? IDX) X) (T (NTHCDR (-- IDX) (CL:CDR X)))))))))
   (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 (~G111) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G111))))
  -(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 ((~G956 (~G169) (CL:LABELS ((~G957 (~G170) (CL:LABELS ((~G958 (A) (CL:LABELS ((~G959 (~G171) (CL:LABELS ((~G960 (K) (CL:LABELS ((~G961 (ARGDEFS) (CL:LABELS ((~G962 (KEY-ARGS) (CL:LABELS ((~G963 (NUM) (CL:LABELS ((~G964 (NO-STATIC) (CL:LABELS ((~G965 (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." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (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." (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 ((~G966 (K) (CL:COND (K (CL:LABELS ((~G967 (!) (CL:LABELS ((~G968 (~G168) (CL:COND (~G168 ~G168) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (LIST (CL:CAR !)))))))) (~G968 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G967 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G966 (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 (LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G969 (~G166) (CL:COND ((EQ ~G166 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G166 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G166 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G969 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (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." (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 ((~G970 (~G167) (CL:COND (~G167 ~G167) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G970 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G971 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G971 (EXP-MAIN ARGDEFS ALST)))))) (~G965 NIL)))) (~G964 NIL)))) (~G963 0)))) (~G962 K)))) (~G961 A)))) (~G960 (CL:CAR ~G171))))) (~G959 (CL:CDR ~G170))))) (~G958 (CL:CAR ~G170))))) (~G957 (CL:CDR ~G169))))) (~G956 (MAKE-&KEY-ALIST ADEF))))))
  +(CL:DEFUN CARLIST (~G114) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G114))))
  +(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 ((~G959 (~G172) (CL:LABELS ((~G960 (~G173) (CL:LABELS ((~G961 (A) (CL:LABELS ((~G962 (~G174) (CL:LABELS ((~G963 (K) (CL:LABELS ((~G964 (ARGDEFS) (CL:LABELS ((~G965 (KEY-ARGS) (CL:LABELS ((~G966 (NUM) (CL:LABELS ((~G967 (NO-STATIC) (CL:LABELS ((~G968 (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." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (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." (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 ((~G969 (K) (CL:COND (K (CL:LABELS ((~G970 (!) (CL:LABELS ((~G971 (~G171) (CL:COND (~G171 ~G171) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (LIST (CL:CAR !)))))))) (~G971 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G970 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G969 (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 (LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G972 (~G169) (CL:COND ((EQ ~G169 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G169 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G169 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G972 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (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." (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 ((~G973 (~G170) (CL:COND (~G170 ~G170) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G973 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G974 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G974 (EXP-MAIN ARGDEFS ALST)))))) (~G968 NIL)))) (~G967 NIL)))) (~G966 0)))) (~G965 K)))) (~G964 A)))) (~G963 (CL:CAR ~G174))))) (~G962 (CL:CDR ~G173))))) (~G961 (CL:CAR ~G173))))) (~G960 (CL:CDR ~G172))))) (~G959 (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 ((~G972 (~G163) (CL:COND (~G163 ~G163) (T (%BODY? X))))) (~G972 (%REST? X))))))
  -(CL:DEFUN %MAP-ARGS (LISTS) (CL:BLOCK %MAP-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G973 (I) (CL:LABELS ((~G974 (NL) (CL:TAGBODY START (CL:COND ((NOT I) (CL:RETURN-FROM NIL (QUEUE-LIST NL)))) (CL:COND ((NOT (CL:CAR I)) (CL:RETURN-FROM NIL NIL))) (ENQUEUE NL (CL:CAR (CL:CAR I))) (CL:RPLACA I (CL:CDR (CL:CAR I))) (CL:SETQ I (CL:CDR I)) (CL:GO START)))) (~G974 (MAKE-QUEUE))))) (~G973 LISTS))))))
  +(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G975 (~G166) (CL:COND (~G166 ~G166) (T (%BODY? X))))) (~G975 (%REST? X))))))
  +(CL:DEFUN %MAP-ARGS (LISTS) (CL:BLOCK %MAP-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G976 (I) (CL:LABELS ((~G977 (NL) (CL:TAGBODY START (CL:COND ((NOT I) (CL:RETURN-FROM NIL (QUEUE-LIST NL)))) (CL:COND ((NOT (CL:CAR I)) (CL:RETURN-FROM NIL NIL))) (ENQUEUE NL (CL:CAR (CL:CAR I))) (CL:RPLACA I (CL:CDR (CL:CAR I))) (CL:SETQ I (CL:CDR I)) (CL:GO START)))) (~G977 (MAKE-QUEUE))))) (~G976 LISTS))))))
   (CL:DEFUN ++ (X) (CL:BLOCK ++ (CL:BLOCK NIL (NUMBER+ X 1))))
  -(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 ((~G975 (~G51) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G51)))) (~G975 START)))) (CL:LABELS ((~G976 (~G52) (CL:COND ((LIST? ~G52) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G52) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G52) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G976 SEQ))))))))
  -(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G977 (~G101) (CL:LABELS ((~G978 (~G102) (CL:LABELS ((~G979 (NUM-CDRS) (CL:LABELS ((~G980 (~G103) (CL:LABELS ((~G981 (WITHOUT-START) (CL:LABELS ((~G982 (~G105) (CL:LABELS ((~G983 (~G106) (CL:LABELS ((~G984 (NUM-CARS) (CL:LABELS ((~G985 (~G107) (CL:LABELS ((~G986 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (MAKE-SYMBOL (LIST-STRING WITHOUT-END))))))) (~G986 (CL:CAR ~G107))))) (~G985 (CL:CDR ~G106))))) (~G984 (CL:CAR ~G106))))) (~G983 (CL:CDR ~G105))))) (~G982 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G981 (CL:CAR ~G103))))) (~G980 (CL:CDR ~G102))))) (~G979 (CL:CAR ~G102))))) (~G978 (CL:CDR ~G101))))) (~G977 (DOT-EXPAND-HEAD-LENGTH X))))))
  -(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G987 (SL) (CL:LABELS ((~G988 (~G110) (CL:COND (~G110 ~G110) (T (EQL #\. (CL:CAR (LAST SL))))))) (~G988 (EQL #\. (CL:CAR SL)))))) (~G987 (STRING-LIST (SYMBOL-NAME X)))))))
  -(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G989 (SL) (CL:LABELS ((~G990 (L) (CL:LABELS ((~G991 (P) (CL:LABELS ((~G992 (~G109) (CL:COND (~G109 ~G109) (T (NOT P))))) (~G992 (== 1 L))))) (~G991 (DOT-POSITION SL))))) (~G990 (CL:LENGTH SL))))) (~G989 (STRING-LIST (SYMBOL-NAME 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 ((~G978 (~G54) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G54)))) (~G978 START)))) (CL:LABELS ((~G979 (~G55) (CL:COND ((LIST? ~G55) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G55) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G55) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G979 SEQ))))))))
  +(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G980 (~G104) (CL:LABELS ((~G981 (~G105) (CL:LABELS ((~G982 (NUM-CDRS) (CL:LABELS ((~G983 (~G106) (CL:LABELS ((~G984 (WITHOUT-START) (CL:LABELS ((~G985 (~G108) (CL:LABELS ((~G986 (~G109) (CL:LABELS ((~G987 (NUM-CARS) (CL:LABELS ((~G988 (~G110) (CL:LABELS ((~G989 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (MAKE-SYMBOL (LIST-STRING WITHOUT-END))))))) (~G989 (CL:CAR ~G110))))) (~G988 (CL:CDR ~G109))))) (~G987 (CL:CAR ~G109))))) (~G986 (CL:CDR ~G108))))) (~G985 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G984 (CL:CAR ~G106))))) (~G983 (CL:CDR ~G105))))) (~G982 (CL:CAR ~G105))))) (~G981 (CL:CDR ~G104))))) (~G980 (DOT-EXPAND-HEAD-LENGTH X))))))
  +(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G990 (SL) (CL:LABELS ((~G991 (~G113) (CL:COND (~G113 ~G113) (T (EQL #\. (CL:CAR (LAST SL))))))) (~G991 (EQL #\. (CL:CAR SL)))))) (~G990 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G992 (SL) (CL:LABELS ((~G993 (L) (CL:LABELS ((~G994 (P) (CL:LABELS ((~G995 (~G112) (CL:COND (~G112 ~G112) (T (NOT P))))) (~G995 (== 1 L))))) (~G994 (DOT-POSITION SL))))) (~G993 (CL:LENGTH SL))))) (~G992 (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 ((~G993 (~G256) (CL:COND ((EQ ~G256 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G256 :CHAR) (READ-CHAR STR)) ((EQ ~G256 :NUMBER) (CL:LABELS ((~G994 (S) (PRINC SYM S) (READ-NUMBER S))) (~G994 (MAKE-STRING-STREAM)))) ((EQ ~G256 :HEXNUM) (READ-HEX STR)) ((EQ ~G256 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G256 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G995 (~G257) (CL:COND ((EQL ~G257 :BRACKET-CLOSE) "round") ((EQL ~G257 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G257 :SQUARE-BRACKET-CLOSE) "square")))) (~G995 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G993 TOKEN)))))
  +(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G996 (~G259) (CL:COND ((EQ ~G259 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G259 :CHAR) (READ-CHAR STR)) ((EQ ~G259 :NUMBER) (CL:LABELS ((~G997 (S) (PRINC SYM S) (READ-NUMBER S))) (~G997 (MAKE-STRING-STREAM)))) ((EQ ~G259 :HEXNUM) (READ-HEX STR)) ((EQ ~G259 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G259 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G998 (~G260) (CL:COND ((EQL ~G260 :BRACKET-CLOSE) "round") ((EQL ~G260 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G260 :SQUARE-BRACKET-CLOSE) "square")))) (~G998 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G996 TOKEN)))))
   (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (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 ((~G996 (~G226) (CL:COND (~G226 ~G226) (T (CL:LABELS ((~G997 (~G227) (CL:COND (~G227 ~G227) (T (CL:LABELS ((~G998 (~G228) (CL:COND (~G228 ~G228) (T (CL:LABELS ((~G999 (~G229) (CL:COND (~G229 ~G229) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G999 (EQL X :QUASIQUOTE-SPLICE))))))) (~G998 (EQL X :QUASIQUOTE))))))) (~G997 (EQL X :BACKQUOTE))))))) (~G996 (EQL X :QUOTE))))))
  -(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1000 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1001 (~G275) (CL:LABELS ((~G1002 (~G276) (CL:LABELS ((~G1003 (TOKEN) (CL:LABELS ((~G1004 (~G277) (CL:LABELS ((~G1005 (PKG) (CL:LABELS ((~G1006 (~G278) (CL:LABELS ((~G1007 (SYM) (READ-SLOT-VALUE (LIST ! SYM)))) (~G1007 (CL:CAR ~G278))))) (~G1006 (CL:CDR ~G277))))) (~G1005 (CL:CAR ~G277))))) (~G1004 (CL:CDR ~G276))))) (~G1003 (CL:CAR ~G276))))) (~G1002 (CL:CDR ~G275))))) (~G1001 (READ-TOKEN STR))))) (T !)))) (~G1000 (READ-CONS STR))))))
  -(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1008 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1009 (~G252) (CL:LABELS ((~G1010 (~G253) (CL:LABELS ((~G1011 (PKG) (CL:LABELS ((~G1012 (~G254) (CL:LABELS ((~G1013 (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 ((~G1014 (~G250) (CL:COND ((EQL ~G250 #\() :BRACKET-OPEN) ((EQL ~G250 #\)) :BRACKET-CLOSE) ((EQL ~G250 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G250 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G250 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G250 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G250 #\') :QUOTE) ((EQL ~G250 #\`) :BACKQUOTE) ((EQL ~G250 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G250 #\") :DBLQUOTE) ((EQL ~G250 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G250 #\#) (CL:LABELS ((~G1015 (~G251) (CL:COND ((EQL ~G251 #\\) :CHAR) ((EQL ~G251 #\x) :HEXNUM) ((EQL ~G251 #\') :FUNCTION) ((EQL ~G251 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1015 (READ-CHAR STR)))) ((EQL ~G250 -1) :EOF)))) (~G1014 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1013 (CL:CAR ~G254))))) (~G1012 (CL:CDR ~G253))))) (~G1011 (CL:CAR ~G253))))) (~G1010 (CL:CDR ~G252))))) (~G1009 !))))))) (~G1008 (READ-SYMBOL-AND-PACKAGE STR))))))
  +(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G999 (~G229) (CL:COND (~G229 ~G229) (T (CL:LABELS ((~G1000 (~G230) (CL:COND (~G230 ~G230) (T (CL:LABELS ((~G1001 (~G231) (CL:COND (~G231 ~G231) (T (CL:LABELS ((~G1002 (~G232) (CL:COND (~G232 ~G232) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G1002 (EQL X :QUASIQUOTE-SPLICE))))))) (~G1001 (EQL X :QUASIQUOTE))))))) (~G1000 (EQL X :BACKQUOTE))))))) (~G999 (EQL X :QUOTE))))))
  +(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1003 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1004 (~G278) (CL:LABELS ((~G1005 (~G279) (CL:LABELS ((~G1006 (TOKEN) (CL:LABELS ((~G1007 (~G280) (CL:LABELS ((~G1008 (PKG) (CL:LABELS ((~G1009 (~G281) (CL:LABELS ((~G1010 (SYM) (READ-SLOT-VALUE (LIST ! SYM)))) (~G1010 (CL:CAR ~G281))))) (~G1009 (CL:CDR ~G280))))) (~G1008 (CL:CAR ~G280))))) (~G1007 (CL:CDR ~G279))))) (~G1006 (CL:CAR ~G279))))) (~G1005 (CL:CDR ~G278))))) (~G1004 (READ-TOKEN STR))))) (T !)))) (~G1003 (READ-CONS STR))))))
  +(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1011 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1012 (~G255) (CL:LABELS ((~G1013 (~G256) (CL:LABELS ((~G1014 (PKG) (CL:LABELS ((~G1015 (~G257) (CL:LABELS ((~G1016 (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 ((~G1017 (~G253) (CL:COND ((EQL ~G253 #\() :BRACKET-OPEN) ((EQL ~G253 #\)) :BRACKET-CLOSE) ((EQL ~G253 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G253 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G253 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G253 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G253 #\') :QUOTE) ((EQL ~G253 #\`) :BACKQUOTE) ((EQL ~G253 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G253 #\") :DBLQUOTE) ((EQL ~G253 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G253 #\#) (CL:LABELS ((~G1018 (~G254) (CL:COND ((EQL ~G254 #\\) :CHAR) ((EQL ~G254 #\x) :HEXNUM) ((EQL ~G254 #\') :FUNCTION) ((EQL ~G254 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1018 (READ-CHAR STR)))) ((EQL ~G253 -1) :EOF)))) (~G1017 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1016 (CL:CAR ~G257))))) (~G1015 (CL:CDR ~G256))))) (~G1014 (CL:CAR ~G256))))) (~G1013 (CL:CDR ~G255))))) (~G1012 !))))))) (~G1011 (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 ((~G1016 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1016 (STREAM-PEEKED-CHAR STR))))))
  -(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1017 (~G159) (CL:LABELS ((~G1018 (S) (CL:LABELS ((~G1019 (~G160) (CL:COND (~G159 ~G160) (T (GET-STREAM-STRING S))))) (~G1019 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1018 (DEFAULT-STREAM ~G159))))) (~G1017 STR)))))
  -(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1020 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1020 (STREAM-OUTPUT-LOCATION STR))))))
  -(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1021 (~G154) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G154)) (~G1021 (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 ((~G1022 (!) (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)))))) (~G1022 (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 ((~G1023 (~G297) (CL:PROGN (=-AREF 'STRUCT ~G297 0) (=-AREF 'FORMAT-INFO ~G297 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G297 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G297 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G297 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G297 5)) ~G297)) (~G1023 (MAKE-ARRAY 6))))))
  -(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1024 (~G148) (CL:COND ((EQL ~G148 NIL) (MAKE-STRING-STREAM)) ((EQL ~G148 T) *STANDARD-OUTPUT*) (T X)))) (~G1024 X)))))
  +(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1019 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1019 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1020 (~G162) (CL:LABELS ((~G1021 (S) (CL:LABELS ((~G1022 (~G163) (CL:COND (~G162 ~G163) (T (GET-STREAM-STRING S))))) (~G1022 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1021 (DEFAULT-STREAM ~G162))))) (~G1020 STR)))))
  +(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1023 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1023 (STREAM-OUTPUT-LOCATION STR))))))
  +(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1024 (~G157) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G157)) (~G1024 (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 ((~G1025 (!) (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)))))) (~G1025 (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 ((~G1026 (~G300) (CL:PROGN (=-AREF 'STRUCT ~G300 0) (=-AREF 'FORMAT-INFO ~G300 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G300 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G300 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G300 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G300 5)) ~G300)) (~G1026 (MAKE-ARRAY 6))))))
  +(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1027 (~G151) (CL:COND ((EQL ~G151 NIL) (MAKE-STRING-STREAM)) ((EQL ~G151 T) *STANDARD-OUTPUT*) (T X)))) (~G1027 X)))))
   (CL:DEFUN -- (X) (CL:BLOCK -- (CL:BLOCK NIL (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 ((~G1025 (~G8) (CL:COND (~G8 ~G8) (T X)))) (~G1025 (CL:CAR X))) VALS))) VALS)))
  +(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1028 (~G8) (CL:COND (~G8 ~G8) (T X)))) (~G1028 (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 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 ((~G1026 (~G138) (CL:PROGN (=-AREF 'STRUCT ~G138 0) (=-AREF 'STREAM ~G138 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G138 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G138 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G138 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G138 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G138 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G138 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G138 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G138 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G138 10)) ~G138)) (~G1026 (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-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 ((~G1029 (~G141) (CL:PROGN (=-AREF 'STRUCT ~G141 0) (=-AREF 'STREAM ~G141 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G141 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G141 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G141 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G141 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G141 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G141 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G141 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G141 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G141 10)) ~G141)) (~G1029 (MAKE-ARRAY 11))))))
  +(CL:DEFUN %MACROEXPAND-BACKQUOTE (X) (CL:COND ((ATOM X) X) ((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 ((~G1027 (A) (CL:LABELS ((~G1028 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1029 (~G128) (CL:LABELS ((~G1030 (I) (CL:TAGBODY ~G126 (CL:COND ((NOT ~G128) (CL:GO ~G127))) (CL:SETQ I (CL:CAR ~G128)) (CL:PROGN (=-AREF I A IDX)) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G128 (CL:CDR ~G128)) (CL:GO ~G126) ~G127 (CL:RETURN-FROM NIL (CL:PROGN A))))) (~G1030 NIL)))) (~G1029 X))))) (~G1028 0)))) (~G1027 (MAKE-ARRAY (CL:LENGTH X)))))))
  -(CL:DEFUN ARRAY-LIST (X) (CL:BLOCK ARRAY-LIST (CL:BLOCK NIL (CL:LABELS ((~G1031 (RESULT) (CL:LABELS ((~G1032 (~G35) (CL:BLOCK NIL (CL:LABELS ((~G1033 (!) (CL:TAGBODY ~G36 (CL:COND ((== ! ~G35) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST RESULT))))) (ENQUEUE RESULT (CL:AREF X !)) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G36)))) (~G1033 0))))) (~G1032 (INTEGER (CL:LENGTH X)))))) (~G1031 (MAKE-QUEUE))))))
  +(CL:DEFUN LIST-ARRAY (X) (CL:BLOCK LIST-ARRAY (CL:BLOCK NIL (CL:LABELS ((~G1030 (A) (CL:LABELS ((~G1031 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1032 (~G131) (CL:LABELS ((~G1033 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (CL:PROGN (=-AREF I A IDX)) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN A))))) (~G1033 NIL)))) (~G1032 X))))) (~G1031 0)))) (~G1030 (MAKE-ARRAY (CL:LENGTH X)))))))
  +(CL:DEFUN ARRAY-LIST (X) (CL:BLOCK ARRAY-LIST (CL:BLOCK NIL (CL:LABELS ((~G1034 (RESULT) (CL:LABELS ((~G1035 (~G38) (CL:BLOCK NIL (CL:LABELS ((~G1036 (!) (CL:TAGBODY ~G39 (CL:COND ((== ! ~G38) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST RESULT))))) (ENQUEUE RESULT (CL:AREF X !)) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G39)))) (~G1036 0))))) (~G1035 (INTEGER (CL:LENGTH X)))))) (~G1034 (MAKE-QUEUE))))))
   (CL:DEFUN MAPCAN (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAN (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION NCONC) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS)))))
  -(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1034 (L) (CL:LABELS ((~G1035 (S) (CL:BLOCK NIL (CL:LABELS ((~G1036 (I) (CL:TAGBODY ~G81 (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 ~G81)))) (~G1036 (-- L)))) S)) (~G1035 NIL)))) (~G1034 (CL:LENGTH X))))))
  +(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1037 (L) (CL:LABELS ((~G1038 (S) (CL:BLOCK NIL (CL:LABELS ((~G1039 (I) (CL:TAGBODY ~G84 (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 ~G84)))) (~G1039 (-- L)))) S)) (~G1038 NIL)))) (~G1037 (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 CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1037 (~G389) (CL:COND (~G389 ~G389) (T (CL:LABELS ((~G1038 (~G390) (CL:COND (~G390 ~G390) (T (CL:LABELS ((~G1039 (~G391) (CL:COND (~G391 ~G391) (T (CL:LABELS ((~G1040 (~G392) (CL:COND (~G392 ~G392) (T (CL:LABELS ((~G1041 (~G393) (CL:COND (~G393 ~G393) (T (CL:LABELS ((~G1042 (~G394) (CL:COND (~G394 ~G394) (T (HASH-TABLE? X))))) (~G1042 (ARRAY? X))))))) (~G1041 (STRING? X))))))) (~G1040 (CHARACTER? X))))))) (~G1039 (NUMBER? X))))))) (~G1038 (EQ T X))))))) (~G1037 (NOT X))))))
  +(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1040 (~G392) (CL:COND (~G392 ~G392) (T (CL:LABELS ((~G1041 (~G393) (CL:COND (~G393 ~G393) (T (CL:LABELS ((~G1042 (~G394) (CL:COND (~G394 ~G394) (T (CL:LABELS ((~G1043 (~G395) (CL:COND (~G395 ~G395) (T (CL:LABELS ((~G1044 (~G396) (CL:COND (~G396 ~G396) (T (CL:LABELS ((~G1045 (~G397) (CL:COND (~G397 ~G397) (T (HASH-TABLE? X))))) (~G1045 (ARRAY? X))))))) (~G1044 (STRING? X))))))) (~G1043 (CHARACTER? X))))))) (~G1042 (NUMBER? X))))))) (~G1041 (EQ T X))))))) (~G1040 (NOT 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 FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1043 (~G299) (CL:LABELS ((~G1044 (NSTR) (CL:LABELS ((~G1045 (~G300) (CL:COND (~G299 ~G300) (T (GET-STREAM-STRING NSTR))))) (~G1045 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1044 (DEFAULT-STREAM ~G299))))) (~G1043 STR)))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1046 (~G161) (CL:LABELS ((~G1047 (S) (CL:LABELS ((~G1048 (~G162) (CL:COND (~G161 ~G162) (T (GET-STREAM-STRING S))))) (~G1048 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1047 (DEFAULT-STREAM ~G161))))) (~G1046 STR)))))
  +(CL:DEFUN FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1046 (~G302) (CL:LABELS ((~G1047 (NSTR) (CL:LABELS ((~G1048 (~G303) (CL:COND (~G302 ~G303) (T (GET-STREAM-STRING NSTR))))) (~G1048 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1047 (DEFAULT-STREAM ~G302))))) (~G1046 STR)))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1049 (~G164) (CL:LABELS ((~G1050 (S) (CL:LABELS ((~G1051 (~G165) (CL:COND (~G164 ~G165) (T (GET-STREAM-STRING S))))) (~G1051 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1050 (DEFAULT-STREAM ~G164))))) (~G1049 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 ((~G1049 (~G214) (CL:COND (~G214 ~G214) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1049 (READ-PEEKED-CHAR STR))))))
  +(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1052 (~G217) (CL:COND (~G217 ~G217) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1052 (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 ((~G1050 (~G281) (CL:LABELS ((~G1051 (~G282) (CL:LABELS ((~G1052 (TOKEN) (CL:LABELS ((~G1053 (~G283) (CL:LABELS ((~G1054 (PKG) (CL:LABELS ((~G1055 (~G284) (CL:LABELS ((~G1056 (SYM) (CL:LABELS ((~G1057 (~G280) (CL:COND ((EQL ~G280 NIL) NIL) ((EQL ~G280 :EOF) NIL) ((EQL ~G280 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G280 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G280 :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))))))) (~G1057 TOKEN)))) (~G1056 (CL:CAR ~G284))))) (~G1055 (CL:CDR ~G283))))) (~G1054 (CL:CAR ~G283))))) (~G1053 (CL:CDR ~G282))))) (~G1052 (CL:CAR ~G282))))) (~G1051 (CL:CDR ~G281))))) (~G1050 (READ-TOKEN STR))))))
  +(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1053 (~G284) (CL:LABELS ((~G1054 (~G285) (CL:LABELS ((~G1055 (TOKEN) (CL:LABELS ((~G1056 (~G286) (CL:LABELS ((~G1057 (PKG) (CL:LABELS ((~G1058 (~G287) (CL:LABELS ((~G1059 (SYM) (CL:LABELS ((~G1060 (~G283) (CL:COND ((EQL ~G283 NIL) NIL) ((EQL ~G283 :EOF) NIL) ((EQL ~G283 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G283 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G283 :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))))))) (~G1060 TOKEN)))) (~G1059 (CL:CAR ~G287))))) (~G1058 (CL:CDR ~G286))))) (~G1057 (CL:CAR ~G286))))) (~G1056 (CL:CDR ~G285))))) (~G1055 (CL:CAR ~G285))))) (~G1054 (CL:CDR ~G284))))) (~G1053 (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 ((~G1058 (SL) (CL:LABELS ((~G1059 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL 0 P))) (CL:CONS (DOT-EXPAND-CONV (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL (++ P))))) NIL))))))) (~G1059 (DOT-POSITION SL))))) (~G1058 (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 DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1061 (SL) (CL:LABELS ((~G1062 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL 0 P))) (CL:CONS (DOT-EXPAND-CONV (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL (++ P))))) NIL))))))) (~G1062 (DOT-POSITION SL))))) (~G1061 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((ATOM X) X) ((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 ((~G1060 (~G137) (CL:PROGN (=-AREF 'STRUCT ~G137 0) (=-AREF 'STREAM-LOCATION ~G137 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G137 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G137 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G137 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G137 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G137 6)) ~G137)) (~G1060 (MAKE-ARRAY 7))))))
  -(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1061 (~G149) (CL:COND ((EQL ~G149 'INPUT) "r") ((EQL ~G149 'OUTPUT) "w") ((EQL ~G149 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1061 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 ((~G1063 (~G140) (CL:PROGN (=-AREF 'STRUCT ~G140 0) (=-AREF 'STREAM-LOCATION ~G140 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G140 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G140 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G140 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G140 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G140 6)) ~G140)) (~G1063 (MAKE-ARRAY 7))))))
  +(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1064 (~G152) (CL:COND ((EQL ~G152 'INPUT) "r") ((EQL ~G152 'OUTPUT) "w") ((EQL ~G152 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1064 DIRECTION)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN FUNCALL (FUN CL:&REST X) (CL:APPLY FUN X))
  -(CL:DEFUN MAPCAR (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAR (CL:BLOCK NIL (CL:LABELS ((~G1062 (ARGS) (CL:COND (ARGS (CL:CONS (CL:APPLY FUNC ARGS) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS)))))) (~G1062 (%MAP-ARGS LISTS))))))
  -(CL:DEFUN CDRLIST (~G112) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G112))))
  -(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1063 (~G164) (CL:COND (~G164 ~G164) (T (%KEY? X))))) (~G1063 (%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 ((~G1064 (!) (CL:COND ((CL:LABELS ((~G1065 (~G173) (CL:COND (~G173 ~G173) (T (EQ ! 'ERROR))))) (~G1065 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1064 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
  +(CL:DEFUN MAPCAR (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAR (CL:BLOCK NIL (CL:LABELS ((~G1065 (ARGS) (CL:COND (ARGS (CL:CONS (CL:APPLY FUNC ARGS) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS)))))) (~G1065 (%MAP-ARGS LISTS))))))
  +(CL:DEFUN CDRLIST (~G115) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G115))))
  +(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1066 (~G167) (CL:COND (~G167 ~G167) (T (%KEY? X))))) (~G1066 (%REST-OR-%BODY? X))))))
  +(CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((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 ((~G1067 (!) (CL:COND ((CL:LABELS ((~G1068 (~G176) (CL:COND (~G176 ~G176) (T (EQ ! 'ERROR))))) (~G1068 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1067 (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 LAST (X) (CL:BLOCK LAST (CL:BLOCK NIL (CL:COND ((CL:CDR X) (LAST (CL:CDR X))) (T X)))))
  -(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:LABELS ((~G1066 (Q) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G37 (CL:COND ((NOT X) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (COPY-HEAD X SIZE)) (CL:PROGN (CL:SETQ X (NTHCDR SIZE X))) (CL:GO ~G37)))))) (~G1066 (MAKE-QUEUE))))))
  -(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1067 (TESTS) (CL:LABELS ((~G1068 (END) (CL:LABELS ((~G1069 (~G665) (CL:COND (~G665 ~G665) (T (ERROR "Body is missing."))))) (~G1069 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (LIST (CL:CONS T END))))) NIL)))) (~G1068 (CL:CAR (LAST TESTS)))))) (~G1067 (GROUP BODY 2))))))
  +(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:LABELS ((~G1069 (Q) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G40 (CL:COND ((NOT X) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (COPY-HEAD X SIZE)) (CL:PROGN (CL:SETQ X (NTHCDR SIZE X))) (CL:GO ~G40)))))) (~G1069 (MAKE-QUEUE))))))
  +(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1070 (TESTS) (CL:LABELS ((~G1071 (END) (CL:LABELS ((~G1072 (~G668) (CL:COND (~G668 ~G668) (T (ERROR "Body is missing."))))) (~G1072 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (LIST (CL:CONS T END))))) NIL)))) (~G1071 (CL:CAR (LAST TESTS)))))) (~G1070 (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?* (LIST X)) (CL:LABELS ((~G1070 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1070 (CL:APPLY *MACROCALL* (LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (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:BLOCK LIST? (CL:BLOCK NIL (CL:LABELS ((~G1071 (~G4) (CL:COND (~G4 ~G4) (T (NOT X))))) (~G1071 (CONS? X))))))
  +(CL:DEFUN %MACROEXPAND (X) (CL:COND ((ATOM X) X) ((CL:APPLY *MACRO?* (LIST X)) (CL:LABELS ((~G1073 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1073 (CL:APPLY *MACROCALL* (LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (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:BLOCK LIST? (CL:BLOCK NIL (CL:LABELS ((~G1074 (~G4) (CL:COND (~G4 ~G4) (T (NOT X))))) (~G1074 (CONS? X))))))
   (CL:DEFUN LIST (CL:&REST X) X)
   (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (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 ((~G1072 (~G116) (CL:LABELS ((~G1073 (I) (CL:TAGBODY ~G114 (CL:COND ((NOT ~G116) (CL:GO ~G115))) (CL:SETQ I (CL:CAR ~G116)) (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 ~G116 (CL:CDR ~G116)) (CL:GO ~G114) ~G115 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1073 NIL)))) (~G1072 LST))))))))
  +(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 ((~G1075 (~G119) (CL:LABELS ((~G1076 (I) (CL:TAGBODY ~G117 (CL:COND ((NOT ~G119) (CL:GO ~G118))) (CL:SETQ I (CL:CAR ~G119)) (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 ~G119 (CL:CDR ~G119)) (CL:GO ~G117) ~G118 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1076 NIL)))) (~G1075 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 ((~G1074 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1074 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  +(CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1077 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1077 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
   (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (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 ((~G1075 (~G215) (CL:COND (~G215 ~G215) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1075 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1078 (~G218) (CL:COND (~G218 ~G218) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1078 (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 ((~G1076 (~G301) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1077 (~G302) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G301)) ~G302)) (~G1077 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1076 *PRINT-AUTOMATIC-NEWLINE?*)))))
  -(CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ANY-QUASIQUOTE? (_) (CL:BLOCK NIL (CL:LABELS ((~G1078 (~G611) (CL:COND (~G611 ~G611) (T (QUASIQUOTE-SPLICE? _))))) (~G1078 (QUASIQUOTE? _))))) (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 ((~G1079 (~G612) (CL:COND ((CL:ATOM ~G612) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G612) (QQ _)) ((QUASIQUOTE-SPLICE? ~G612) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1079 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1080 (~G613) (CL:COND ((QUOTE? ~G613) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G613) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1080 _)))) (WALK (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (DISP _)) (T (CL:CONS (WALK (DISP (CL:CAR _))) (WALK (CL:CDR _)))))))) (CL:CAR (WALK (LIST X)))))))
  +(CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1079 (~G304) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1080 (~G305) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G304)) ~G305)) (~G1080 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1079 *PRINT-AUTOMATIC-NEWLINE?*)))))
  +(CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ANY-QUASIQUOTE? (_) (CL:BLOCK NIL (CL:LABELS ((~G1081 (~G614) (CL:COND (~G614 ~G614) (T (QUASIQUOTE-SPLICE? _))))) (~G1081 (QUASIQUOTE? _))))) (ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((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 ((ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1082 (~G615) (CL:COND ((ATOM ~G615) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G615) (QQ _)) ((QUASIQUOTE-SPLICE? ~G615) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1082 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1083 (~G616) (CL:COND ((QUOTE? ~G616) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G616) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1083 _)))) (WALK (_) (CL:BLOCK NIL (CL:COND ((ATOM _) (DISP _)) (T (CL:CONS (WALK (DISP (CL:CAR _))) (WALK (CL:CDR _)))))))) (CL:CAR (WALK (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 _ #\~) (LIST _ _)) (T (LIST _))))) (STRING-LIST X))))))
   (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 MAPCAR) FUNC (MAPCAR (CL:FUNCTION STRING-LIST) LISTS)))) ((ARRAY? (CL:CAR LISTS)) (LIST-ARRAY (CL:APPLY (CL:FUNCTION MAPCAR) FUNC (MAPCAR (CL:FUNCTION ARRAY-LIST) LISTS)))) (T (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS))))))
  -(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1081 (~G3) (CL:COND (~G3 ~G3) (T (CL:ATOM Y))))) (~G1081 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  +(CL:DEFUN ATOM (X) (NOT (CONS? X)))
  +(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1084 (~G3) (CL:COND (~G3 ~G3) (T (ATOM Y))))) (~G1084 (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 (CL:&OPTIONAL (PREFIX "~G")) (CL:LABELS ((~G1082 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1082 (MAKE-SYMBOL (STRING-CONCAT PREFIX (STRING (GENSYM-NUMBER)))))))
  -(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1083 (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)))))))) (~G1083 (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 ((~G1084 (I) (CL:TAGBODY ~G11 (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 ~G11)))) (~G1084 LST))))))
  +(CL:DEFUN GENSYM (CL:&OPTIONAL (PREFIX "~G")) (CL:LABELS ((~G1085 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1085 (MAKE-SYMBOL (STRING-CONCAT PREFIX (STRING (GENSYM-NUMBER)))))))
  +(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1086 (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)))))))) (~G1086 (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 ((~G1087 (I) (CL:TAGBODY ~G11 (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 ~G11)))) (~G1087 LST))))))
   (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (LIST X)))))
   (CL:DEFUN IDENTITY (X) X)
   "Section DELAYED-EXPRS"
  
positive.code: (CL:SETQ *MACROEXPAND-BACKQUOTE* (CL:FUNCTION %MACROEXPAND-BACKQUOTE))
  (CL:SETQ *MACROCALL* NIL)
  (CL:SETQ *MACRO?* NIL)
  (CL:SETQ +CL-FUNCTION-IMPORTS+ (CL:CONS 'CL:ATOM (CL:CONS 'CL:APPLY (CL:CONS 'CL:CONS (CL:CONS 'CL:CAR (CL:CONS 'CL:CDR (CL:CONS 'CL:RPLACA (CL:CONS 'CL:RPLACD (CL:CONS 'CL:LENGTH (CL:CONS 'CL:MAKE-STRING (CL:CONS 'CL:MOD (CL:CONS 'CL:SQRT (CL:CONS 'CL:SIN (CL:CONS 'CL:COS (CL:CONS 'CL:TAN (CL:CONS 'CL:ASIN (CL:CONS 'CL:ACOS (CL:CONS 'CL:ATAN (CL:CONS 'CL:EXP (CL:CONS 'CL:ROUND (CL:CONS 'CL:FLOOR (CL:CONS 'CL:AREF (CL:CONS 'CL:CHAR-CODE (CL:CONS 'CL:MAKE-PACKAGE (CL:CONS 'CL:PACKAGE-NAME (CL:CONS 'CL:FIND-PACKAGE (CL:CONS 'CL:PRINT (CL:CONS 'CL:BREAK NIL))))))))))))))))))))))))))))
  (CL:SETQ *STANDARD-OUTPUT* (MAKE-STANDARD-STREAM))
  (CL:SETQ *GENSYM-COUNTER* 0)
  (CL:SETQ *VALUES-MAGIC* 'VALUES-~G27)
  (CL:SETQ *PRINTER-ABBREVIATIONS* (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS "'" NIL)) (CL:CONS (CL:CONS 'BACKQUOTE (CL:CONS "`" NIL)) (CL:CONS (CL:CONS 'QUASIQUOTE (CL:CONS "," NIL)) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (CL:CONS ",@" NIL)) NIL)))))
  (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* NIL)
  (CL:SETQ *INVISIBLE-PACKAGE-NAMES* (CL:CONS "TRE" (CL:CONS "TRE-CORE" NIL)))
  
negative.code: (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 =-FORMAT-INFO-PROCESSED-ARGS (VAL ARR) (CL:BLOCK =-FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN FORMAT-INFO-PROCESSED-ARGS (ARR) (CL:BLOCK FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:LABELS ((~G886 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G886 (CL:CAR LSTS))))))))
  (CL:DEFUN %FORMAT-DIRECTIVE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE (CL:BLOCK NIL (CL:PROGN (=-FORMAT-INFO-PROCESSED-ARGS (NUMBER+ (FORMAT-INFO-PROCESSED-ARGS INF) 1) INF)) (CL:LABELS ((~G887 (~G301) (CL:COND ((EQL ~G301 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((EQL ~G301 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((EQL ~G301 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) ((EQL ~G301 #\L) (%FORMAT-DIRECTIVE-FRESH-LINE INF (CL:CDR TXT) ARGS)) ((EQL ~G301 #\~) (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G887 (CHAR-UPCASE (CL:CAR TXT)))))))
  (CL:DEFUN FORMAT-INFO-STREAM (ARR) (CL:BLOCK FORMAT-INFO-STREAM (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
  