anchor.diff:  (CL:DEFUN STREAM-LOCATION-ID (ARR) (CL:BLOCK STREAM-LOCATION-ID (CL:BLOCK NIL (CL:AREF ARR 3))))
   (CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  -(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 ((~G1586 (~G319) (CL:COND ((CHARACTER== ~G319 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((CHARACTER== ~G319 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((CHARACTER== ~G319 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G1586 (CHAR-UPCASE (CL:CAR TXT)))))))
  +(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 ((~G1603 (~G320) (CL:COND ((CHARACTER== ~G320 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((CHARACTER== ~G320 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((CHARACTER== ~G320 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G1603 (CHAR-UPCASE (CL:CAR TXT)))))))
   (CL:DEFUN %FORMAT-DIRECTIVE-TILDE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-TILDE (CL:BLOCK NIL (PRINC #\~ (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
   (CL:DEFUN %FORMAT-DIRECTIVE-FORCE-OUTPUT (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-FORCE-OUTPUT (CL:BLOCK NIL (FORCE-OUTPUT (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
   (CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN %FORMAT-DIRECTIVE-PLACEHOLDER (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-PLACEHOLDER (CL:BLOCK NIL (CL:COND (ARGS (CL:COND ((CONS? (CL:CAR ARGS)) (LATE-PRINT (CL:CAR ARGS) (FORMAT-INFO-STREAM INF))) (T (PRINC (CL:CAR ARGS) (FORMAT-INFO-STREAM INF))))) (T (ERROR "Argument ~A specified in format \"~A\" is missing." (FORMAT-INFO-PROCESSED-ARGS INF) (FORMAT-INFO-TEXT INF)))) (%FORMAT INF TXT (CL:CDR ARGS)))))
   (CL:DEFUN FORMAT-INFO-TEXT (ARR) (CL:BLOCK FORMAT-INFO-TEXT (CL:BLOCK NIL (CL:AREF ARR 3))))
  -(CL:DEFUN LATE-PRINT (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*) (PRINT-INFO NIL)) (CL:BLOCK LATE-PRINT (CL:BLOCK NIL (CL:LABELS ((~G1587 (~G220) (CL:LABELS ((~G1588 (S) (CL:LABELS ((~G1589 (~G221) (CL:COND (~G220 ~G221) (T (GET-STREAM-STRING S))))) (~G1589 (CL:PROGN (%LATE-PRINT X S (CL:LABELS ((~G1590 (~G219) (CL:COND (~G219 ~G219) (T (MAKE-PRINT-INFO))))) (~G1590 PRINT-INFO))) (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (CL:PROGN (TERPRI S))))))))) (~G1588 (DEFAULT-STREAM ~G220))))) (~G1587 STR)) X)))
  -(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1591 (~G175) (CL:LABELS ((~G1592 (S) (CL:LABELS ((~G1593 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1593 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1592 (DEFAULT-STREAM ~G175))))) (~G1591 STR)))))
  -(CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION) (NO-PADDING? 'NO-PADDING?)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1594 (~G190) (CL:PROGN (=-AREF 'STRUCT ~G190 0) (=-AREF 'PRINT-INFO ~G190 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) NIL) (T PRETTY-PRINT?)) ~G190 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G190 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G190 4)) (CL:PROGN (=-AREF (CL:COND ((EQ NO-PADDING? 'NO-PADDING?) T) (T NO-PADDING?)) ~G190 5)) ~G190)) (~G1594 (MAKE-ARRAY 6))))))
  -(CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:COND ((CONS? X) (%PRINT-CONS X STR INFO)) (T (%PRINT-ATOM X STR INFO))))))
  -(CL:DEFUN %PRINT-ATOM (X STR INFO) (CL:BLOCK %PRINT-ATOM (CL:BLOCK NIL (CL:PROGN (CL:COND ((PRINT-INFO-NO-PADDING? INFO) (CL:PROGN (=-PRINT-INFO-NO-PADDING? NIL INFO))) (T (PRINC " " STR))) (CL:LABELS ((~G1595 (~G218) (CL:COND ((SYMBOL? ~G218) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G218) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G218) (PRINC X STR)) ((STRING? ~G218) (%PRINT-STRING X STR)) ((ARRAY? ~G218) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G218) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G218) (%PRINT-OBJECT X STR INFO)) (T "UNKNOWN OBJECT")))) (~G1595 X))))))
  +(CL:DEFUN LATE-PRINT (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*) (PRINT-INFO NIL)) (CL:BLOCK LATE-PRINT (CL:BLOCK NIL (CL:LABELS ((~G1604 (~G221) (CL:LABELS ((~G1605 (S) (CL:LABELS ((~G1606 (~G222) (CL:COND (~G221 ~G222) (T (GET-STREAM-STRING S))))) (~G1606 (CL:PROGN (FUNCALL (CL:COND ((CL:COND ((CONS? X) (CONS? (CL:CAR X)))) #'%PRINT-BODY) (T #'%LATE-PRINT)) X S (CL:LABELS ((~G1607 (~G220) (CL:COND (~G220 ~G220) (T (MAKE-PRINT-INFO))))) (~G1607 PRINT-INFO))) (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (CL:COND ((NOT (FRESH-LINE? STR)) (TERPRI S)))))))))) (~G1605 (DEFAULT-STREAM ~G221))))) (~G1604 STR)) X)))
  +(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1608 (~G175) (CL:LABELS ((~G1609 (S) (CL:LABELS ((~G1610 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1610 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1609 (DEFAULT-STREAM ~G175))))) (~G1608 STR)))))
  +(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1611 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1611 (STREAM-OUTPUT-LOCATION STR))))))
  +(CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1612 (~G190) (CL:PROGN (=-AREF 'STRUCT ~G190 0) (=-AREF 'PRINT-INFO ~G190 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) T) (T PRETTY-PRINT?)) ~G190 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G190 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G190 4)) ~G190)) (~G1612 (MAKE-ARRAY 5))))))
  +(CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:LABELS ((~G1613 (~G219) (CL:COND ((CONS? ~G219) (%PRINT-CONS X STR INFO)) ((SYMBOL? ~G219) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G219) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G219) (PRINC X STR)) ((STRING? ~G219) (%PRINT-STRING X STR)) ((ARRAY? ~G219) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G219) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G219) (%PRINT-OBJECT X STR INFO)) (T (%ERROR "Don't know how to print object."))))) (~G1613 X))))))
   (CL:DEFUN %PRINT-OBJECT (X STR INFO) (CL:BLOCK %PRINT-OBJECT (CL:BLOCK NIL)))
   (CL:DEFUN OBJECT? (X) (CL:BLOCK OBJECT? (CL:BLOCK NIL X NIL)))
   (CL:DEFUN %PRINT-FUNCTION (X STR INFO) (CL:BLOCK %PRINT-FUNCTION (CL:BLOCK NIL (PRINC "#'" STR) (%LATE-PRINT (CL:CONS (FUNCTION-ARGUMENTS X) (FUNCTION-BODY X)) STR INFO))))
   (CL:DEFUN FUNCTION-BODY (FUN) (CL:BLOCK FUNCTION-BODY (CL:BLOCK NIL (CL:COND ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 1)) (T (CL:CDR (FUNCTION-SOURCE FUN)))))))
   (CL:DEFUN FUNCTION-ARGUMENTS (FUN) (CL:BLOCK FUNCTION-ARGUMENTS (CL:BLOCK NIL (CL:COND ((BUILTIN? FUN) (CL:CONS 'CL:&REST (CL:CONS 'ARGS-TO-BUILTIN NIL))) ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 0)) (T (CL:CAR (FUNCTION-SOURCE FUN)))))))
  -(CL:DEFUN %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (CL:PROGN (CL:COND ((PRINT-INFO-NO-PADDING? INFO) (CL:PROGN (=-PRINT-INFO-NO-PADDING? NIL INFO))) (T (PRINC " " STR))) (PRINC "(" STR) (CL:PROGN (=-PRINT-INFO-NO-PADDING? T INFO)) (CL:LABELS ((~G1596 (~G214) (CL:COND (~G214 (CL:PROGN (CL:LABELS ((~G1597 (~G216) (CL:BLOCK NIL (CL:LABELS ((~G1598 (~G215) (CL:TAGBODY ~G217 (CL:COND ((INTEGER== ~G215 ~G216) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1599 (I) (%LATE-PRINT I STR INFO))) (~G1599 (CL:AREF ~G214 ~G215))) (CL:SETQ ~G215 (INTEGER+ 1 ~G215)) (CL:GO ~G217)))) (~G1598 0))))) (~G1597 (INTEGER (CL:LENGTH ~G214))))))))) (~G1596 X)) (PRINC ")" STR)))))
  -(CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G1600 (~G206) (CL:LABELS ((~G1601 (I) (CL:TAGBODY ~G204 (CL:COND ((NOT ~G206) (CL:GO ~G205))) (CL:SETQ I (CL:CAR ~G206)) (CL:COND ((== I #\") (PRINC "\\\"" STR)) ((== I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G206 (CL:CDR ~G206)) (CL:GO ~G204) ~G205 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1601 NIL)))) (~G1600 (STRING-LIST X)))) (PRINC #\" STR))))
  +(CL:DEFUN %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (CL:LABELS ((~G1614 (~G215) (CL:COND (~G215 (CL:PROGN (CL:LABELS ((~G1615 (~G217) (CL:COND ((INTEGER< ~G217 0) (ERROR "Negative number of iterations: ~A." ~G217))) (CL:BLOCK NIL (CL:LABELS ((~G1616 (~G216) (CL:TAGBODY ~G218 (CL:COND ((INTEGER== ~G216 ~G217) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1617 (I) (%LATE-PRINT I STR INFO))) (~G1617 (CL:AREF ~G215 ~G216))) (CL:SETQ ~G216 (INTEGER+ 1 ~G216)) (CL:GO ~G218)))) (~G1616 0))))) (~G1615 (INTEGER (CL:LENGTH ~G215))))))))) (~G1614 X)) (PRINC ")" STR)))))
  +(CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G1618 (~G207) (CL:LABELS ((~G1619 (I) (CL:TAGBODY ~G205 (CL:COND ((NOT ~G207) (CL:GO ~G206))) (CL:SETQ I (CL:CAR ~G207)) (CL:COND ((== I #\") (PRINC "\\\"" STR)) ((== I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G207 (CL:CDR ~G207)) (CL:GO ~G205) ~G206 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1619 NIL)))) (~G1618 (STRING-LIST X)))) (PRINC #\" STR))))
   (CL:DEFUN %PRINT-CHARACTER (X STR) (CL:BLOCK %PRINT-CHARACTER (CL:BLOCK NIL (PRINC "#\\" STR) (PRINC X STR))))
  -(CL:DEFUN %PRINT-SYMBOL (X STR INFO) (CL:BLOCK %PRINT-SYMBOL (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G1602 (~G211) (CL:COND (~G211 ~G211) (T (EQ T X))))) (~G1602 (NOT X)))) (CL:PROGN (CL:LABELS ((~G1603 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1604 (!) (CL:COND ((NOT (CL:COND ((NOT *ALWAYS-PRINT-PACKAGE-NAMES?*) (CL:LABELS ((~G1605 (~G212) (CL:COND (~G212 ~G212) (T (STRING== ! "TRE-CORE"))))) (~G1605 (STRING== ! "TRE")))))) (CL:PROGN (CL:LABELS ((~G1606 (~G213) (CL:COND (~G213 ~G213) (T (%PRINT-SYMBOL-PACKAGE ! STR))))) (~G1606 (KEYWORD? X))) (PRINC #\: STR)))))) (~G1604 (CL:PACKAGE-NAME !)))))))) (~G1603 (SYMBOL-PACKAGE X)))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
  +(CL:DEFUN %PRINT-SYMBOL (X STR INFO) (CL:BLOCK %PRINT-SYMBOL (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G1620 (~G212) (CL:COND (~G212 ~G212) (T (EQ T X))))) (~G1620 (NOT X)))) (CL:PROGN (CL:LABELS ((~G1621 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1622 (!) (CL:COND ((NOT (CL:COND ((NOT *ALWAYS-PRINT-PACKAGE-NAMES?*) (CL:LABELS ((~G1623 (~G213) (CL:COND (~G213 ~G213) (T (STRING== ! "TRE-CORE"))))) (~G1623 (STRING== ! "TRE")))))) (CL:PROGN (CL:LABELS ((~G1624 (~G214) (CL:COND (~G214 ~G214) (T (%PRINT-SYMBOL-PACKAGE ! STR))))) (~G1624 (KEYWORD? X))) (PRINC #\: STR)))))) (~G1622 (CL:PACKAGE-NAME !)))))))) (~G1621 (SYMBOL-PACKAGE X)))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
   (CL:DEFUN %PRINT-SYMBOL-COMPONENT (X STR) (CL:BLOCK %PRINT-SYMBOL-COMPONENT (CL:BLOCK NIL (CL:COND ((SOME #'SYMBOL-CHAR-NEEDS-ESCAPING? (STRING-LIST X)) (%PRINT-ESCAPED-SYMBOL X STR)) (T (PRINC X STR))))))
  -(CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G1607 (~G209) (CL:LABELS ((~G1608 (I) (CL:TAGBODY ~G207 (CL:COND ((NOT ~G209) (CL:GO ~G208))) (CL:SETQ I (CL:CAR ~G209)) (CL:COND ((== I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G209 (CL:CDR ~G209)) (CL:GO ~G207) ~G208 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1608 NIL)))) (~G1607 (STRING-LIST X)))) (PRINC #\| STR))))
  -(CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G1609 (~G210) (CL:COND (~G210 ~G210) (T (LOWER-CASE? X))))) (~G1609 (== #\| X))))))
  -(CL:DEFUN LOWER-CASE? (CL:&REST ~G64) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1610 (~G68) (CL:LABELS ((~G1611 (C) (CL:TAGBODY ~G66 (CL:COND ((NOT ~G68) (CL:GO ~G67))) (CL:SETQ C (CL:CAR ~G68)) (CL:LABELS ((~G1612 (~G65) (CL:COND (~G65 ~G65) (T (CL:RETURN-FROM NIL NIL))))) (~G1612 (RANGE? C #\a #\z))) (CL:SETQ ~G68 (CL:CDR ~G68)) (CL:GO ~G66) ~G67 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1611 NIL)))) (~G1610 ~G64))))))
  +(CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G1625 (~G210) (CL:LABELS ((~G1626 (I) (CL:TAGBODY ~G208 (CL:COND ((NOT ~G210) (CL:GO ~G209))) (CL:SETQ I (CL:CAR ~G210)) (CL:COND ((== I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G210 (CL:CDR ~G210)) (CL:GO ~G208) ~G209 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1626 NIL)))) (~G1625 (STRING-LIST X)))) (PRINC #\| STR))))
  +(CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G1627 (~G211) (CL:COND (~G211 ~G211) (T (LOWER-CASE? X))))) (~G1627 (== #\| X))))))
  +(CL:DEFUN LOWER-CASE? (CL:&REST ~G64) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1628 (~G68) (CL:LABELS ((~G1629 (C) (CL:TAGBODY ~G66 (CL:COND ((NOT ~G68) (CL:GO ~G67))) (CL:SETQ C (CL:CAR ~G68)) (CL:LABELS ((~G1630 (~G65) (CL:COND (~G65 ~G65) (T (CL:RETURN-FROM NIL NIL))))) (~G1630 (RANGE? C #\a #\z))) (CL:SETQ ~G68 (CL:CDR ~G68)) (CL:GO ~G66) ~G67 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1629 NIL)))) (~G1628 ~G64))))))
   (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  -(CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1613 (~G13) (CL:LABELS ((~G1614 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1615 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1616 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1616 (> N I))))))) (~G1615 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1614 NIL)))) (~G1613 X))))))
  +(CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1631 (~G13) (CL:LABELS ((~G1632 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1633 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1634 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1634 (> N I))))))) (~G1633 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1632 NIL)))) (~G1631 X))))))
   (CL:DEFUN SOME (PRED CL:&REST SEQS) (CL:BLOCK SOME (CL:BLOCK NIL (FIND-IF PRED (CL:APPLY #'APPEND SEQS)))))
   (CL:DEFUN FIND-IF (PRED SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (WITH-INDEX NIL)) (CL:BLOCK FIND-IF (CL:BLOCK NIL (CL:COND ((NOT (CL:ATOM SEQ) START END) (%FIND-IF-LIST PRED SEQ FROM-END WITH-INDEX)) (T (%FIND-IF-SEQUENCE PRED SEQ START END FROM-END WITH-INDEX))))))
  -(CL:DEFUN %FIND-IF-SEQUENCE (PRED SEQ START END FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-SEQUENCE (CL:BLOCK NIL (CL:COND (SEQ (CL:COND ((< 0 (CL:LENGTH SEQ)) (CL:LABELS ((~G1617 (E) (CL:LABELS ((~G1618 (S) (CL:COND ((CL:LABELS ((~G1619 (~G101) (CL:COND (~G101 ~G101) (T (CL:COND ((< S E) FROM-END)))))) (~G1619 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1620 (~G102) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G102)))) (~G1620 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1621 (I) (CL:TAGBODY ~G103 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1622 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1622 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G103)))) (~G1621 S))))) (~G1618 (CL:LABELS ((~G1623 (~G100) (CL:COND (~G100 ~G100) (T 0)))) (~G1623 START)))))) (~G1617 (CL:LABELS ((~G1624 (~G99) (CL:COND (~G99 ~G99) (T (-- (CL:LENGTH SEQ)))))) (~G1624 END)))))))))))
  -(CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1625 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1626 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1627 (~G95) (CL:LABELS ((~G1628 (!) (CL:TAGBODY ~G93 (CL:COND ((NOT ~G95) (CL:GO ~G94))) (CL:SETQ ! (CL:CAR ~G95)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G95 (CL:CDR ~G95)) (CL:GO ~G93) ~G94 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1628 NIL)))) (~G1627 !))))) (~G1626 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1629 (~G98) (CL:LABELS ((~G1630 (!) (CL:TAGBODY ~G96 (CL:COND ((NOT ~G98) (CL:GO ~G97))) (CL:SETQ ! (CL:CAR ~G98)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G98 (CL:CDR ~G98)) (CL:GO ~G96) ~G97 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1630 NIL)))) (~G1629 !))))))) (~G1625 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  +(CL:DEFUN %FIND-IF-SEQUENCE (PRED SEQ START END FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-SEQUENCE (CL:BLOCK NIL (CL:COND (SEQ (CL:COND ((< 0 (CL:LENGTH SEQ)) (CL:LABELS ((~G1635 (E) (CL:LABELS ((~G1636 (S) (CL:COND ((CL:LABELS ((~G1637 (~G101) (CL:COND (~G101 ~G101) (T (CL:COND ((< S E) FROM-END)))))) (~G1637 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1638 (~G102) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G102)))) (~G1638 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1639 (I) (CL:TAGBODY ~G103 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1640 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1640 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G103)))) (~G1639 S))))) (~G1636 (CL:LABELS ((~G1641 (~G100) (CL:COND (~G100 ~G100) (T 0)))) (~G1641 START)))))) (~G1635 (CL:LABELS ((~G1642 (~G99) (CL:COND (~G99 ~G99) (T (-- (CL:LENGTH SEQ)))))) (~G1642 END)))))))))))
  +(CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1643 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1644 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1645 (~G95) (CL:LABELS ((~G1646 (!) (CL:TAGBODY ~G93 (CL:COND ((NOT ~G95) (CL:GO ~G94))) (CL:SETQ ! (CL:CAR ~G95)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G95 (CL:CDR ~G95)) (CL:GO ~G93) ~G94 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1646 NIL)))) (~G1645 !))))) (~G1644 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1647 (~G98) (CL:LABELS ((~G1648 (!) (CL:TAGBODY ~G96 (CL:COND ((NOT ~G98) (CL:GO ~G97))) (CL:SETQ ! (CL:CAR ~G98)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G98 (CL:CDR ~G98)) (CL:GO ~G96) ~G97 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1648 NIL)))) (~G1647 !))))))) (~G1643 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
   (CL:DEFUN %PRINT-SYMBOL-PACKAGE (NAME STR) (CL:BLOCK %PRINT-SYMBOL-PACKAGE (CL:BLOCK NIL (%PRINT-SYMBOL-COMPONENT (CL:COND ((STRING== "COMMON-LISP" NAME) "CL") (T NAME)) STR))))
  -(CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  -(CL:DEFUN =-PRINT-INFO-NO-PADDING? (VAL ARR) (CL:BLOCK =-PRINT-INFO-NO-PADDING? (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  -(CL:DEFUN PRINT-INFO-NO-PADDING? (ARR) (CL:BLOCK PRINT-INFO-NO-PADDING? (CL:BLOCK NIL (CL:AREF ARR 5))))
  -(CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G1631 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G1631 (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST #'EQ))))))))
  -(CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:PROGN (CL:COND ((PRINT-INFO-NO-PADDING? INFO) (CL:PROGN (=-PRINT-INFO-NO-PADDING? NIL INFO))) (T (PRINC " " STR))) (PRINC "(" STR) (CL:PROGN (=-PRINT-INFO-NO-PADDING? T INFO)) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G1632 (!) (CL:COND (! (%PRINT-CALL (CL:CDR X) ! STR INFO)) (T (%PRINT-REST (CL:CDR X) STR INFO))))) (~G1632 (%PRINT-CALL? X INFO))) (PRINC ")" STR)))))
  -(CL:DEFUN %PRINT-REST (X STR INFO) (CL:BLOCK %PRINT-REST (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:PROGN (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO))) (T (CL:PROGN (PRINC " . " STR) (%PRINT-ATOM X STR INFO))))))))))
  +(CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G1649 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G1649 (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST #'EQ))))))))
  +(CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G1650 (!) (CL:COND (! (%PRINT-CALL (CL:CDR X) ! STR INFO)) (T (%PRINT-REST (CL:CDR X) STR INFO))))) (~G1650 NIL)) (PRINC ")" STR)))))
  +(CL:DEFUN %PRINT-REST (X STR INFO) (CL:BLOCK %PRINT-REST (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:PROGN (CL:LABELS ((~G1651 (~G193) (CL:COND (~G193 ~G193) (T (PRINC " " STR))))) (~G1651 (FRESH-LINE? STR))) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO))) (T (CL:PROGN (PRINC " . " STR) (%LATE-PRINT X STR INFO))))))))))
   (CL:DEFUN %PRINT-CALL (X ARGDEF STR INFO) (CL:BLOCK %PRINT-CALL (CL:BLOCK NIL (%PRINT-ARGS (%PRINT-GET-ARGS X ARGDEF) STR INFO))))
   (CL:DEFUN %PRINT-GET-ARGS (ARGS DEF) (CL:BLOCK %PRINT-GET-ARGS (CL:BLOCK NIL (ARGUMENT-EXPAND 'CL:PRINT DEF ARGS :CONCATENATE-SUBLISTS? NIL))))
  -(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:COND (APPLY-VALUES? (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS?)) (T (CARLIST (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS?)))))))
  -(CL:DEFUN CARLIST (~G126) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER #'CL:CAR ~G126))))
  -(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1633 (~G185) (CL:LABELS ((~G1634 (~G186) (CL:COND ((NOT (EQ (CL:CAR ~G185) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G185)))) (CL:LABELS ((~G1635 (A) (CL:LABELS ((~G1636 (~G187) (CL:LABELS ((~G1637 (K) (CL:LABELS ((~G1638 (ARGDEFS) (CL:LABELS ((~G1639 (KEY-ARGS) (CL:LABELS ((~G1640 (NUM) (CL:LABELS ((~G1641 (NO-STATIC) (CL:LABELS ((~G1642 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (ERROR "; Call of function ~A: ~A~%; Argument definition: ~A~%; Given arguments: ~A~%" (SYMBOL-NAME FUN) (CL:APPLY #'FORMAT NIL MSG ARGS) ADEF ALST)) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (ERR "static argument definition after ~A" (CL:LIST NO-STATIC)))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (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)) (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 ((~G1643 (K) (CL:COND (K (CL:LABELS ((~G1644 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1644 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1643 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST #'EQ)))) (EXP-REST (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 '%REST VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1645 (~G183) (CL:COND ((EQ ~G183 'CL:&REST) (EXP-REST DEF VALS)) ((EQ ~G183 'CL:&BODY) (EXP-REST DEF VALS)) ((EQ ~G183 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1645 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (ERR "static sublevel argument definition after ~A" (CL:LIST NO-STATIC)))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (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?) (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?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (ERR "too many arguments. ~A max, 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 ((~G1646 (~G184) (CL:COND (~G184 ~G184) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1646 (EXP-CHECK-TOO-MANY DEF VALS))))))) (%NCONC (EXP-MAIN ARGDEFS ALST) (%NCONC KEY-ARGS REST-ARG))))) (~G1642 NIL)))) (~G1641 NIL)))) (~G1640 0)))) (~G1639 K)))) (~G1638 A)))) (~G1637 (CL:CAR ~G187))))) (~G1636 (CL:LABELS ((~G1647 (~G189) (CL:COND (~G189 ~G189) (T (%ERROR "Not enough VALUES."))))) (~G1647 (CL:CDR ~G186))))))) (~G1635 (CL:CAR ~G186))))) (~G1634 (CL:CDR ~G185))))) (~G1633 (MAKE-&KEY-ALIST ADEF))))))
  -(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:MAPCAR #'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 ((~G1648 (~G180) (CL:COND (~G180 ~G180) (T (CL:LABELS ((~G1649 (~G181) (CL:COND (~G181 ~G181) (T (CL:LABELS ((~G1650 (~G182) (CL:COND (~G182 ~G182) (T (EQ X 'CL:&KEY))))) (~G1650 (EQ X 'CL:&OPTIONAL))))))) (~G1649 (EQ X 'CL:&BODY))))))) (~G1648 (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 ((~G1651 (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 ((~G1652 (!) (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 _)))) (~G1652 (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))))) (~G1651 NIL)))))
  -(CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  -(CL:DEFUN %PRINT-ARGS (X STR INFO) (CL:BLOCK %PRINT-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1653 (~G203) (CL:LABELS ((~G1654 (!) (CL:TAGBODY ~G201 (CL:COND ((NOT ~G203) (CL:GO ~G202))) (CL:SETQ ! (CL:CAR ~G203)) (CL:COND ((NOT (CL:CAR !)) (CL:PROGN (CL:COND ((PRINT-INFO-NO-PADDING? INFO) (CL:PROGN (=-PRINT-INFO-NO-PADDING? NIL INFO))) (T (PRINC " " STR))) (PRINC "(" STR) (CL:PROGN (=-PRINT-INFO-NO-PADDING? T INFO)) (%PRINT-ARGS (CL:CDR !) STR INFO) (PRINC ")" STR))) ((CONS? (CL:CDR !)) (CL:LABELS ((~G1655 (~G198) (CL:COND ((EQ ~G198 'CL:&BODY) (%PRINT-BODY (CL:CDR (CL:CDR !)) STR INFO)) ((EQ ~G198 'CL:&REST) (%PRINT-REST (CL:CDR (CL:CDR !)) STR INFO)) (T (%PRINT-CONS (CL:CDR !) STR INFO))))) (~G1655 (CL:CAR (CL:CDR !))))) (T (CL:LABELS ((~G1656 (~G199) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1657 (~G200) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G199)) ~G200)) (~G1657 (CL:PROGN (%LATE-PRINT (CL:CDR !) STR INFO)))))) (~G1656 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G203 (CL:CDR ~G203)) (CL:GO ~G201) ~G202 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1654 NIL)))) (~G1653 X))))))
  -(CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (TERPRI STR) (CL:LABELS ((~G1658 (~G193) (CL:PROGN (=-PRINT-INFO-INDENTATION (++ (PRINT-INFO-INDENTATION INFO)) INFO)) (CL:LABELS ((~G1659 (~G197) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G193 INFO)) ~G197)) (~G1659 (CL:PROGN (CL:BLOCK NIL (CL:LABELS ((~G1660 (~G196) (CL:LABELS ((~G1661 (!) (CL:TAGBODY ~G194 (CL:COND ((NOT ~G196) (CL:GO ~G195))) (CL:SETQ ! (CL:CAR ~G196)) (%PRINT-INDENTATION STR INFO) (%LATE-PRINT ! STR INFO) (CL:COND ((NOT (EQ ! (CL:CAR (CL:LAST X)))) (CL:PROGN (TERPRI STR)))) (CL:SETQ ~G196 (CL:CDR ~G196)) (CL:GO ~G194) ~G195 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1661 NIL)))) (~G1660 X)))))))) (~G1658 (PRINT-INFO-INDENTATION INFO))))))
  -(CL:DEFUN %PRINT-INDENTATION (STR INFO) (CL:BLOCK %PRINT-INDENTATION (CL:BLOCK NIL (CL:LABELS ((~G1662 (~G191) (CL:BLOCK NIL (CL:LABELS ((~G1663 (!) (CL:TAGBODY ~G192 (CL:COND ((INTEGER== ! ~G191) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G192)))) (~G1663 0))))) (~G1662 (INTEGER (PRINT-INFO-INDENTATION INFO)))) (CL:PROGN (=-PRINT-INFO-NO-PADDING? T INFO)))))
  +(CL:DEFUN %PRINT-ARGS (X STR INFO) (CL:BLOCK %PRINT-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1652 (~G204) (CL:LABELS ((~G1653 (!) (CL:TAGBODY ~G202 (CL:COND ((NOT ~G204) (CL:GO ~G203))) (CL:SETQ ! (CL:CAR ~G204)) (CL:COND ((NOT (CL:CAR !)) (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (%PRINT-ARGS (CL:CDR !) STR INFO) (PRINC ")" STR))) ((CONS? (CL:CDR !)) (CL:LABELS ((~G1654 (~G199) (CL:COND ((EQ ~G199 'CL:&BODY) (%PRINT-BODY (CL:CDR (CL:CDR !)) STR INFO)) ((EQ ~G199 'CL:&REST) (%PRINT-REST (CL:CDR (CL:CDR !)) STR INFO)) (T (%PRINT-CONS (CL:CDR !) STR INFO))))) (~G1654 (CL:CAR (CL:CDR !))))) (T (CL:LABELS ((~G1655 (~G200) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1656 (~G201) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G200)) ~G201)) (~G1656 (CL:PROGN (%LATE-PRINT (CL:CDR !) STR INFO)))))) (~G1655 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G204 (CL:CDR ~G204)) (CL:GO ~G202) ~G203 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1653 NIL)))) (~G1652 X))))))
  +(CL:DEFUN %PRINT-ABBREVIATION (ABBREVIATION X STR INFO) (CL:BLOCK %PRINT-ABBREVIATION (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC (CL:CAR (CL:CDR ABBREVIATION)) STR) (%LATE-PRINT (CL:CAR (CL:CDR X)) STR INFO)))))
  +(CL:DEFUN %PRINT-INDENTATION (STR INFO) (CL:BLOCK %PRINT-INDENTATION (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((FRESH-LINE? STR) (CL:LABELS ((~G1657 (~G191) (CL:COND ((INTEGER< ~G191 0) (ERROR "Negative number of iterations: ~A." ~G191))) (CL:BLOCK NIL (CL:LABELS ((~G1658 (!) (CL:TAGBODY ~G192 (CL:COND ((INTEGER== ! ~G191) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G192)))) (~G1658 0))))) (~G1657 (INTEGER (PRINT-INFO-INDENTATION INFO)))))))))))
  +(CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
  +(CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
  +(CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (CL:LABELS ((~G1659 (~G194) (CL:PROGN (=-PRINT-INFO-INDENTATION (++ (PRINT-INFO-INDENTATION INFO)) INFO)) (CL:LABELS ((~G1660 (~G198) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G194 INFO)) ~G198)) (~G1660 (CL:PROGN (CL:BLOCK NIL (CL:LABELS ((~G1661 (~G197) (CL:LABELS ((~G1662 (!) (CL:TAGBODY ~G195 (CL:COND ((NOT ~G197) (CL:GO ~G196))) (CL:SETQ ! (CL:CAR ~G197)) (FRESH-LINE STR) (%LATE-PRINT ! STR INFO) (CL:SETQ ~G197 (CL:CDR ~G197)) (CL:GO ~G195) ~G196 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1662 NIL)))) (~G1661 X)))))))) (~G1659 (PRINT-INFO-INDENTATION INFO))))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1663 (~G177) (CL:LABELS ((~G1664 (S) (CL:LABELS ((~G1665 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1665 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1664 (DEFAULT-STREAM ~G177))))) (~G1663 STR)))))
   (CL:DEFUN =-PRINT-INFO-INDENTATION (VAL ARR) (CL:BLOCK =-PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  -(CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
  -(CL:DEFUN %PRINT-CALL? (X INFO) (CL:BLOCK %PRINT-CALL? (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G1664 (!) (CL:COND (! (CL:COND ((FUNCTION? !) (FUNCTION-ARGUMENTS !))))))) (~G1664 (SYMBOL-FUNCTION (CL:CAR X)))))))))))
  -(CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
  -(CL:DEFUN %PRINT-ABBREVIATION (ABBREVIATION X STR INFO) (CL:BLOCK %PRINT-ABBREVIATION (CL:BLOCK NIL (CL:PROGN (CL:COND ((PRINT-INFO-NO-PADDING? INFO) (CL:PROGN (=-PRINT-INFO-NO-PADDING? NIL INFO))) (T (PRINC " " STR))) (PRINC (CL:CAR (CL:CDR ABBREVIATION)) STR) (CL:PROGN (=-PRINT-INFO-NO-PADDING? T INFO)) (%LATE-PRINT (CL:CAR (CL:CDR X)) STR INFO)))))
   (CL:DEFUN %FORMAT-DIRECTIVE-EOL (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-EOL (CL:BLOCK NIL (TERPRI (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
   (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CHARACTER+ C (CHARACTER- #\A #\a))) (T C)))))
   (CL:DEFUN FORMAT-INFO-PROCESSED-ARGS (ARR) (CL:BLOCK FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:AREF ARR 5))))
   (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 DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1665 (~G163) (CL:COND ((EQ ~G163 NIL) (MAKE-STRING-STREAM)) ((EQ ~G163 T) *STANDARD-OUTPUT*) (T X)))) (~G1665 X)))))
  -(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) (CL:LABELS ((~G1666 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1666 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR) X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
  -(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1667 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1667 (CL:CAR X))) VALS))) VALS)))
  -(CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1668 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G1668 (CL:CAR (CL:CDR X)))))))
  +(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1666 (~G163) (CL:COND ((EQ ~G163 NIL) (MAKE-STRING-STREAM)) ((EQ ~G163 T) *STANDARD-OUTPUT*) (T X)))) (~G1666 X)))))
  +(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) (CL:LABELS ((~G1667 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1667 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR) X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
  +(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1668 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1668 (CL:CAR X))) VALS))) VALS)))
  +(CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1669 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G1669 (CL:CAR (CL:CDR X)))))))
   (CL:DEFUN ENQUEUE-LIST (X VALS) (CL:BLOCK ENQUEUE-LIST (CL:BLOCK NIL (CL:RPLACD X (NCONC (CL:CDR X) VALS)) (CL:RPLACA X (CL:LAST VALS)))))
   (CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
  -(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1669 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1669 (CL:CAR 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 ((~G1670 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G156 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G156 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G156 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G156 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G156 10)) ~G156)) (~G1670 (MAKE-ARRAY 11))))))
  -(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 ((~G1671 (~G155) (CL:PROGN (=-AREF 'STRUCT ~G155 0) (=-AREF 'STREAM-LOCATION ~G155 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G155 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G155 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G155 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G155 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G155 6)) ~G155)) (~G1671 (MAKE-ARRAY 7))))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1672 (~G177) (CL:LABELS ((~G1673 (S) (CL:LABELS ((~G1674 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1674 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1673 (DEFAULT-STREAM ~G177))))) (~G1672 STR)))))
  -(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (== (STREAM-LAST-CHAR STR) (CODE-CHAR 10)))))
  -(CL:DEFUN STREAM-LAST-CHAR (ARR) (CL:BLOCK STREAM-LAST-CHAR (CL:BLOCK NIL (CL:AREF ARR 6))))
  -(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:CONS (COPY-HEAD X SIZE) (GROUP (CL:NTHCDR SIZE X) SIZE)))))))
  -(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 ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  +(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1670 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1670 (CL:CAR 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 ((~G1671 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G156 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G156 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G156 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G156 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G156 10)) ~G156)) (~G1671 (MAKE-ARRAY 11))))))
  +(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 ((~G1672 (~G155) (CL:PROGN (=-AREF 'STRUCT ~G155 0) (=-AREF 'STREAM-LOCATION ~G155 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G155 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G155 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G155 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G155 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G155 6)) ~G155)) (~G1672 (MAKE-ARRAY 7))))))
  +(CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G1673 (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 ((~G1674 (!) (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 _)))) (~G1674 (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))))) (~G1673 NIL)))))
  +(CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
   (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) 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 (%MACROEXPAND-CALL (CL:COND ((EQ (CL:CAR X) 'CL:QUOTE) X) (T (%MACROEXPAND-REST 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 %MACROEXPAND-CALL (X) (CL:COND ((CL:APPLY *MACRO?* (CL:LIST X)) (%MACROEXPAND-XLAT X)) (T X)))
  
positive.code: (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (LIST-STRING (READ-STRING-0 STR)))))
  (CL:DEFUN READ-STRING-0 (STR) (CL:BLOCK READ-STRING-0 (CL:BLOCK NIL (CL:LABELS ((~G1762 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1762 (READ-CHAR STR))))))
  (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST TOKEN (READ-EXPR STR)))))
  (CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1763 (~G235) (CL:COND (~G235 ~G235) (T (CL:LABELS ((~G1764 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G1765 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G1766 (~G238) (CL:COND (~G238 ~G238) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1766 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1765 (EQ X 'QUASIQUOTE))))))) (~G1764 (EQ X 'BACKQUOTE))))))) (~G1763 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1767 (~G295) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1768 (~G301) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G295)) ~G301)) (~G1768 (CL:PROGN (CL:LABELS ((~G1769 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1770 (~G296) (CL:LABELS ((~G1771 (~G297) (CL:COND ((NOT (EQ (CL:CAR ~G296) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G296)))) (CL:LABELS ((~G1772 (TOKEN) (CL:LABELS ((~G1773 (~G298) (CL:LABELS ((~G1774 (PKG) (CL:LABELS ((~G1775 (~G299) (CL:LABELS ((~G1776 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1776 (CL:CAR ~G299))))) (~G1775 (CL:LABELS ((~G1777 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1777 (CL:CDR ~G298))))))) (~G1774 (CL:CAR ~G298))))) (~G1773 (CL:LABELS ((~G1778 (~G302) (CL:COND (~G302 ~G302) (T (%ERROR "Not enough VALUES."))))) (~G1778 (CL:CDR ~G297))))))) (~G1772 (CL:CAR ~G297))))) (~G1771 (CL:CDR ~G296))))) (~G1770 (READ-TOKEN STR))))) (T !)))) (~G1769 (READ-CONS STR)))))))) (~G1767 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1779 (LOC) (CL:LABELS ((~G1780 (LINE) (CL:LABELS ((~G1781 (COLUMN) (CL:LABELS ((~G1782 (FILE) (CL:LABELS ((ERR (_) (CL:BLOCK NIL (ERROR "~A in form starting at line ~A, column ~A in file ~A." _ LINE COLUMN FILE))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G1783 (~G269) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1784 (~G272) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G269)) ~G272)) (~G1784 (CL:PROGN (CL:LABELS ((~G1785 (~G268) (CL:COND ((EQ ~G268 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G268 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G268 '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))))))) (~G1785 TOKEN))))))) (~G1783 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1786 (~G271) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1787 (~G278) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G271)) ~G278)) (~G1787 (CL:PROGN (CL:LABELS ((~G1788 (!) (CL:COND (! (CL:LABELS ((~G1789 (~G273) (CL:LABELS ((~G1790 (~G274) (CL:COND ((NOT (EQ (CL:CAR ~G273) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G273)))) (CL:LABELS ((~G1791 (TOKEN) (CL:LABELS ((~G1792 (~G275) (CL:LABELS ((~G1793 (PKG) (CL:LABELS ((~G1794 (~G276) (CL:LABELS ((~G1795 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1796 (X) (CL:LABELS ((~G1797 (~G281) (CL:LABELS ((~G1798 (~G282) (CL:COND ((NOT (EQ (CL:CAR ~G281) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G281)))) (CL:LABELS ((~G1799 (TOKEN) (CL:LABELS ((~G1800 (~G283) (CL:LABELS ((~G1801 (PKG) (CL:LABELS ((~G1802 (~G284) (CL:LABELS ((~G1803 (SYM) (CL:LABELS ((~G1804 (~G270) (CL:COND (~G270 ~G270) (T (ERR "Only one value allowed after dotted cons."))))) (~G1804 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1803 (CL:CAR ~G284))))) (~G1802 (CL:LABELS ((~G1805 (~G287) (CL:COND (~G287 ~G287) (T (%ERROR "Not enough VALUES."))))) (~G1805 (CL:CDR ~G283))))))) (~G1801 (CL:CAR ~G283))))) (~G1800 (CL:LABELS ((~G1806 (~G286) (CL:COND (~G286 ~G286) (T (%ERROR "Not enough VALUES."))))) (~G1806 (CL:CDR ~G282))))))) (~G1799 (CL:CAR ~G282))))) (~G1798 (CL:CDR ~G281))))) (~G1797 (READ-TOKEN STR))))) (~G1796 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1795 (CL:CAR ~G276))))) (~G1794 (CL:LABELS ((~G1807 (~G280) (CL:COND (~G280 ~G280) (T (%ERROR "Not enough VALUES."))))) (~G1807 (CL:CDR ~G275))))))) (~G1793 (CL:CAR ~G275))))) (~G1792 (CL:LABELS ((~G1808 (~G279) (CL:COND (~G279 ~G279) (T (%ERROR "Not enough VALUES."))))) (~G1808 (CL:CDR ~G274))))))) (~G1791 (CL:CAR ~G274))))) (~G1790 (CL:CDR ~G273))))) (~G1789 !))) (T (ERR "Closing bracket missing."))))) (~G1788 (READ-TOKEN STR)))))))) (~G1786 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1809 (~G288) (CL:LABELS ((~G1810 (~G289) (CL:COND ((NOT (EQ (CL:CAR ~G288) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G288)))) (CL:LABELS ((~G1811 (TOKEN) (CL:LABELS ((~G1812 (~G290) (CL:LABELS ((~G1813 (PKG) (CL:LABELS ((~G1814 (~G291) (CL:LABELS ((~G1815 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1815 (CL:CAR ~G291))))) (~G1814 (CL:LABELS ((~G1816 (~G294) (CL:COND (~G294 ~G294) (T (%ERROR "Not enough VALUES."))))) (~G1816 (CL:CDR ~G290))))))) (~G1813 (CL:CAR ~G290))))) (~G1812 (CL:LABELS ((~G1817 (~G293) (CL:COND (~G293 ~G293) (T (%ERROR "Not enough VALUES."))))) (~G1817 (CL:CDR ~G289))))))) (~G1811 (CL:CAR ~G289))))) (~G1810 (CL:CDR ~G288))))) (~G1809 (READ-TOKEN STR)))))) (~G1782 (STREAM-LOCATION-ID LOC))))) (~G1781 (STREAM-LOCATION-COLUMN LOC))))) (~G1780 (STREAM-LOCATION-LINE LOC))))) (~G1779 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1818 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1818 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1819 (~G222) (CL:COND (~G222 ~G222) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1819 (HREF *MEMORIZED-NUMBERS* X))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1820 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1821 (~G261) (CL:LABELS ((~G1822 (~G262) (CL:COND ((NOT (EQ (CL:CAR ~G261) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G261)))) (CL:LABELS ((~G1823 (PKG) (CL:LABELS ((~G1824 (~G263) (CL:LABELS ((~G1825 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (== #\. (CL:CAR SYM)))))) 'DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) 'NUMBER) (T 'SYMBOL))) (T (CL:LABELS ((~G1826 (~G260) (CL:COND ((CHARACTER== ~G260 #\() 'BRACKET-OPEN) ((CHARACTER== ~G260 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G260 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G260 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G260 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G260 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G260 #\') 'CL:QUOTE) ((CHARACTER== ~G260 #\`) 'BACKQUOTE) ((CHARACTER== ~G260 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G260 #\") 'DBLQUOTE) ((CHARACTER== ~G260 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G260 #\#) (CL:LABELS ((~G1827 (~G259) (CL:COND ((CHARACTER== ~G259 #\\) 'CHAR) ((CHARACTER== ~G259 #\x) 'HEXNUM) ((CHARACTER== ~G259 #\') 'CL:FUNCTION) ((CHARACTER== ~G259 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1827 (READ-CHAR STR)))) ((CHARACTER== ~G260 -1) 'EOF)))) (~G1826 (READ-CHAR STR))))))) PKG SYM))) (~G1825 (CL:CAR ~G263))))) (~G1824 (CL:LABELS ((~G1828 (~G265) (CL:COND (~G265 ~G265) (T (%ERROR "Not enough VALUES."))))) (~G1828 (CL:CDR ~G262))))))) (~G1823 (CL:CAR ~G262))))) (~G1822 (CL:CDR ~G261))))) (~G1821 !))))))) (~G1820 (GET-SYMBOL-AND-PACKAGE STR))))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G255 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G255)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1829 (~G257) (CL:COND (~G257 ~G257) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1829 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1830 (~G256) (CL:COND (~G256 ~G256) (T (== #\. (CL:CAR X)))))) (~G1830 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1831 (~G258) (CL:COND (~G258 ~G258) (T (== #\. _))))) (~G1831 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1832 (~G108) (CL:LABELS ((~G1833 (SEQ) (CL:TAGBODY ~G106 (CL:COND ((NOT ~G108) (CL:GO ~G107))) (CL:SETQ SEQ (CL:CAR ~G108)) (CL:LABELS ((~G1834 (~G105) (CL:BLOCK NIL (CL:LABELS ((~G1835 (!) (CL:TAGBODY ~G109 (CL:COND ((INTEGER== ! ~G105) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1836 (~G104) (CL:COND (~G104 ~G104) (T (CL:RETURN-FROM EVERY NIL))))) (~G1836 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G109)))) (~G1835 0))))) (~G1834 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G108 (CL:CDR ~G108)) (CL:GO ~G106) ~G107 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1833 NIL)))) (~G1832 SEQS))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1837 (SYM) (CL:LABELS ((~G1838 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1839 (~G254) (CL:COND (~G254 ~G254) (T T)))) (~G1839 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1838 (PEEK-CHAR STR))))) (~G1837 (GET-SYMBOL STR))))))
  (CL:DEFUN GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1840 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1840 (PEEK-CHAR STR))))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1841 (C) (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR) (GET-SYMBOL-0 STR))) (T (CL:COND ((SYMBOL-CHAR? C) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (GET-SYMBOL-0 STR)))))))) (~G1841 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1842 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1842 (READ-CHAR STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1843 (C) (CL:COND (C (CL:PROGN (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? C) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR))))))))) (~G1843 (PEEK-CHAR STR))))))
  (CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((< X 33) (>= X 0))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1844 (~G224) (CL:COND (~G224 ~G224) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1844 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G898 (X) (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 ((~G1845 (~G896) (CL:COND ((CL:ATOM ~G896) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G896) (QQ _)) ((QUASIQUOTE-SPLICE? ~G896) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1845 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1846 (~G897) (CL:COND ((QUOTE? ~G897) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G897) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1846 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING #'DISP))))) (CL:COND ((NOT (DUMP-PASS? 'QUOTE-EXPAND)) (CL:PROGN (CL:RETURN-FROM NIL (~G898 X))))) (FRESH-LINE) (FORMAT T "; **** QUOTE-EXPAND~%") (CL:LABELS ((~G1847 (~G899) (FRESH-LINE) (FORMAT T "; **** end of QUOTE-EXPAND~%") ~G899)) (~G1847 (CL:LABELS ((~G1848 (~G900) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* X)) (CL:LABELS ((~G1849 (~G902) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* ~G900)) ~G902)) (~G1849 (CL:PROGN (CL:LABELS ((~G1850 (~G901) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* T)) (CL:LABELS ((~G1851 (~G903) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* ~G901)) ~G903)) (~G1851 (CL:PROGN (LATE-PRINT (~G898 X))))))) (~G1850 *ALWAYS-PRINT-PACKAGE-NAMES?*))))))) (~G1848 *CURRENT-PASS-INPUT*))))))))
  (CL:DEFUN DUMP-PASS? (NAME) (CL:BLOCK DUMP-PASS? (CL:BLOCK NIL (CL:COND (*TRANSPILER* (CL:LABELS ((~G1852 (!) (CL:COND (! (CL:LABELS ((~G1853 (~G431) (CL:COND (~G431 ~G431) (T (MEMBER NAME (ENSURE-LIST !)))))) (~G1853 (EQ T !))))))) (~G1852 (DUMP-PASSES?))))))))
  (CL:DEFUN ENSURE-LIST (X) (CL:BLOCK ENSURE-LIST (CL:BLOCK NIL (CL:COND ((CONS? X) X) (T (CL:LIST X))))))
  (CL:DEFUN MEMBER (ELM LST CL:&KEY (TEST #'EQL)) (CL:BLOCK MEMBER (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1854 (I) (CL:TAGBODY ~G23 (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 ~G23)))) (~G1854 LST))))))
  (CL:DEFUN DUMP-PASSES? NIL (CL:BLOCK DUMP-PASSES? (CL:BLOCK NIL (CL:AREF *TRANSPILER* 61))))
  (CL:DEFUN TREE-WALK (I CL:&KEY (ASCENDING NIL) (DONT-ASCEND-IF NIL) (DONT-ASCEND-AFTER-IF NIL)) (CL:BLOCK TREE-WALK (CL:BLOCK NIL (CL:COND ((CL:ATOM I) (FUNCALL ASCENDING I)) (T (CL:PROGN (CL:LABELS ((~G1855 (Y) (CL:LABELS ((~G1856 (A) (CL:PROGN (CL:LABELS ((~G1857 (~G363) (CL:LABELS ((~G1858 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1858 (CL:COND ((CONS? ~G363) (CPR ~G363))))))) (~G1857 I)) (CL:LABELS ((~G1859 (~G362) (RPLACP (CL:CONS A (TREE-WALK (CL:CDR I) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF)) ~G362))) (~G1859 *DEFAULT-LISTPROP*))))) (~G1856 (CL:LABELS ((~G1860 (~G361) (CL:COND (~G361 ~G361) (T (CL:COND ((CL:COND (DONT-ASCEND-AFTER-IF (FUNCALL DONT-ASCEND-AFTER-IF Y))) (FUNCALL ASCENDING Y)) (T (TREE-WALK (CL:COND (ASCENDING (FUNCALL ASCENDING Y)) (T Y)) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF))))))) (~G1860 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1855 (CL:CAR I)))))))))
  (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 ((~G1861 (~G422) (CL:COND (~G422 ~G422) (T (CL:LABELS ((~G1862 (~G423) (CL:COND (~G423 ~G423) (T (CL:LABELS ((~G1863 (~G424) (CL:COND (~G424 ~G424) (T (CL:LABELS ((~G1864 (~G425) (CL:COND (~G425 ~G425) (T (CL:LABELS ((~G1865 (~G426) (CL:COND (~G426 ~G426) (T (HASH-TABLE? X))))) (~G1865 (ARRAY? X))))))) (~G1864 (STRING? X))))))) (~G1863 (NUMBER? X))))))) (~G1862 (EQ T X))))))) (~G1861 (NOT X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1866 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1866 (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 ((~G1867 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1867 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1868 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) #'APPEND) ((STRING? A) #'STRING-CONCAT) (T #'NUMBER+)) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY #'+ (CL:CDR X)))))))) (~G1868 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFVAR *GENSYM-PREFIX*)
  
negative.code: (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST 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 READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (SKIP-SPACES STR) (CL:COND ((PEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1719 (~G306) (CL:LABELS ((~G1720 (~G307) (CL:COND ((NOT (EQ (CL:CAR ~G306) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G306)))) (CL:LABELS ((~G1721 (TOKEN) (CL:LABELS ((~G1722 (~G308) (CL:LABELS ((~G1723 (PKG) (CL:LABELS ((~G1724 (~G309) (CL:LABELS ((~G1725 (SYM) (CL:LABELS ((~G1726 (~G305) (CL:COND ((EQ ~G305 NIL) NIL) ((EQ ~G305 'EOF) NIL) ((EQ ~G305 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G305 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G305 '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))))))) (~G1726 TOKEN)))) (~G1725 (CL:CAR ~G309))))) (~G1724 (CL:LABELS ((~G1727 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1727 (CL:CDR ~G308))))))) (~G1723 (CL:CAR ~G308))))) (~G1722 (CL:LABELS ((~G1728 (~G311) (CL:COND (~G311 ~G311) (T (%ERROR "Not enough VALUES."))))) (~G1728 (CL:CDR ~G307))))))) (~G1721 (CL:CAR ~G307))))) (~G1720 (CL:CDR ~G306))))) (~G1719 (READ-TOKEN STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1729 (~G268) (CL:COND ((EQ ~G268 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G268 'CHAR) (READ-CHAR STR)) ((EQ ~G268 'NUMBER) (CL:LABELS ((~G1730 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1730 (MAKE-STRING-STREAM)))) ((EQ ~G268 'HEXNUM) (READ-HEX STR)) ((EQ ~G268 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G268 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1731 (~G267) (CL:COND ((EQUAL ~G267 'BRACKET-CLOSE) "Round") ((EQUAL ~G267 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G267 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1731 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1729 TOKEN)))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1732 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G1733 (~G241) (CL:COND (~G241 ~G241) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1733 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1732 (EQ X 'BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1734 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (CL:COND (*READER-FINDS-SYMBOLS?* (CL:FIND-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) CL:*PACKAGE*) (T (CL:FIND-PACKAGE (CL:COND ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))))) (~G1734 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS 'SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X))) NIL)) NIL)))) (T (CL:COND ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))))))
  (CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST #'EQL) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (GENERIC-SPLIT OBJ SEQ :TEST TEST :INCLUDE? INCLUDE?))))
  (CL:DEFUN GENERIC-SPLIT (OBJ SEQ CL:&KEY (TEST #'EQL) (INCLUDE? NIL)) (CL:BLOCK GENERIC-SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G1735 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1735 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1736 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1736 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1737 (~G226) (CL:COND (~G226 ~G226) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1737 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1738 (~G227) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G227)) (~G1738 (REC 0)))))))
  (CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND ((> X 32) (NOT (SPECIAL-CHAR? X)))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1739 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G1740 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G1741 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G1742 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1743 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1744 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1745 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G1746 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1747 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G1748 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1749 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1750 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1751 (~G254) (CL:COND (~G254 ~G254) (T (== X #\^))))) (~G1751 (== X #\#))))))) (~G1750 (== X #\"))))))) (~G1749 (== X #\;))))))) (~G1748 (== X #\:))))))) (~G1747 (== X #\,))))))) (~G1746 (== X #\`))))))) (~G1745 (== X #\'))))))) (~G1744 (== X #\}))))))) (~G1743 (== X #\{))))))) (~G1742 (== X #\]))))))) (~G1741 (== X #\[))))))) (~G1740 (== X #\)))))))) (~G1739 (== X #\())))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1752 (~G81) (CL:COND (~G81 ~G81) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1752 (DECIMAL-DIGIT? C))))))))
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G1753 (~G80) (CL:COND (~G80 ~G80) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1753 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN %NONDECIMAL-DIGIT? (X START BASE) (CL:BLOCK %NONDECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X START (CHARACTER+ START (CHARACTER- BASE 10))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X #\0 #\9))))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1754 (~G82) (CL:COND (~G82 ~G82) (T (CL:LABELS ((~G1755 (~G83) (CL:COND (~G83 ~G83) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1755 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1754 (DIGIT-CHAR? X))))))
  (CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((== #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1756 (~G228) (CL:COND (~G228 ~G228) (T 0)))) (~G1756 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  (CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1757 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1757 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  (CL:DEFUN READ-DECIMAL-PLACES-0 (STR V S) (CL:BLOCK READ-DECIMAL-PLACES-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-DECIMAL-PLACES-0 STR (+ V (* S (DIGIT-NUMBER (READ-CHAR STR)))) (/ S 10))) (T V)))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- X #\0))))
  