anchor.diff:  (CL:PROGN (CL:DEFUN =-SYMBOL-FUNCTION (V X) (CL:SETF (CL:SYMBOL-FUNCTION X) V)) (CL:SETF (CL:GETHASH '=-SYMBOL-FUNCTION *BUILTIN-ATOMS*) (CL:FUNCTION =-SYMBOL-FUNCTION)))
   (CL:PROGN (CL:DEFUN FIND-SYMBOL (X CL:&OPTIONAL (PKG *PACKAGE*)) (CL:FIND-SYMBOL X *PACKAGE*)) (CL:SETF (CL:GETHASH 'FIND-SYMBOL *BUILTIN-ATOMS*) (CL:FUNCTION FIND-SYMBOL)))
   (CL:DEFUN TRE-SYMBOL (X) (CL:INTERN (SYMBOL-NAME X) "TRE"))
  +(CL:PROGN (CL:DEFUN DEFPACKAGE (NAME CL:&REST OPTIONS) (PRINT-DEFINITION `(DEFPACKAGE ,NAME ,@OPTIONS)) (CL:EVAL `(CL:DEFPACKAGE ,NAME ,@OPTIONS)) NIL) (CL:SETF (CL:GETHASH 'DEFPACKAGE *BUILTIN-ATOMS*) (CL:FUNCTION DEFPACKAGE)))
  +(CL:PROGN (CL:DEFUN IN-PACKAGE (NAME) (PRINT-DEFINITION `(IN-PACKAGE ,NAME ,@OPTIONS)) (CL:PROGN (CL:SETQ *PACKAGE* (SYMBOL-NAME NAME))) NIL) (CL:SETF (CL:GETHASH 'IN-PACKAGE *BUILTIN-ATOMS*) (CL:FUNCTION IN-PACKAGE)))
   (CL:PROGN (CL:DEFUN SH (PROGRAM CL:&REST ARGUMENTS) (SB-EXT:RUN-PROGRAM PROGRAM ARGUMENTS :PTY CL:*STANDARD-OUTPUT*)) (CL:SETF (CL:GETHASH 'SH *BUILTIN-ATOMS*) (CL:FUNCTION SH)))
   (CL:PROGN (CL:DEFUN UNIX-SH-CP (FROM TO CL:&KEY (VERBOSE? NIL) (RECURSIVELY? NIL)) (CL:APPLY (CL:FUNCTION SH) "/bin/cp" `(,@(CL:COND (VERBOSE? '("-v"))) ,@(CL:COND (RECURSIVELY? '("-r"))) ,FROM ,TO))) (CL:SETF (CL:GETHASH 'UNIX-SH-CP *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-CP)))
   (CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:APPLY (CL:FUNCTION SH) "/bin/mkdir" `(,@(CL:COND (PARENTS '("-p"))) ,PATHNAME))) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-MKDIR)))
  
positive.code: (CL:DEFUN %GET-PRINTER-ARGUMENT-DEFINITION (X) (CL:BLOCK %GET-PRINTER-ARGUMENT-DEFINITION (CL:BLOCK NIL (HREF *PRINTER-ARGUMENT-DEFINITIONS* X))))
  (CL:DEFUN MAKE-KEYWORD (X) (CL:BLOCK MAKE-KEYWORD (CL:BLOCK NIL (CL:COND (X (MAKE-SYMBOL (CL:COND ((SYMBOL? X) (SYMBOL-NAME X)) (T X)) *KEYWORD-PACKAGE*))))))
  (CL:DEFUN %PRINT-GET-ARGS (ARGS DEF) (CL:BLOCK %PRINT-GET-ARGS (CL:BLOCK NIL (ARGUMENT-EXPAND 'CL:PRINT DEF ARGS :CONCATENATE-SUBLISTS? NIL :BREAK-ON-ERRORS? NIL))))
  (CL:DEFUN %PRINT-GAP (STR) (CL:BLOCK %PRINT-GAP (CL:BLOCK NIL (CL:LABELS ((~G784 (~G187) (CL:COND (~G187 ~G187) (T (PRINC " " STR))))) (~G784 (FRESH-LINE? STR))))))
  (CL:DEFUN INVISIBLE-PACKAGE? (X) (CL:BLOCK INVISIBLE-PACKAGE? (CL:BLOCK NIL (CL:LABELS ((~G785 (!) (SOME (CL:LAMBDA (_) (CL:BLOCK NIL (STRING== ! _))) *INVISIBLE-PACKAGE-NAMES*))) (~G785 (CL:PACKAGE-NAME X))))))
  (CL:DEFUN ABBREVIATED-PACKAGE-NAME (X) (CL:BLOCK ABBREVIATED-PACKAGE-NAME (CL:BLOCK NIL (CL:COND ((STRING== "COMMON-LISP" X) "CL") (T X)))))
  (CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G786 (~G207) (CL:LABELS ((~G787 (I) (CL:TAGBODY ~G205 (CL:COND ((NOT ~G207) (CL:GO ~G206))) (CL:SETQ I (CL:CAR ~G207)) (CL:COND ((EQL I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G207 (CL:CDR ~G207)) (CL:GO ~G205) ~G206 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G787 NIL)))) (~G786 (STRING-LIST X)))) (PRINC #\| STR))))
  (CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G788 (~G208) (CL:COND (~G208 ~G208) (T (LOWER-CASE? X))))) (~G788 (EQL #\| X))))))
  (CL:DEFUN SOME (PRED CL:&REST SEQS) (CL:BLOCK SOME (CL:BLOCK NIL (FIND-IF PRED (CL:APPLY (CL:FUNCTION APPEND) SEQS)))))
  (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 (%PRINT-GAP 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 (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G789 (EXPANDED) (CL:COND ((EQ EXPANDED 'ERROR) (%PRINT-REST (CL:CDR X) STR INFO)) (T (CL:BLOCK NIL (CL:LABELS ((~G790 (~G200) (CL:LABELS ((~G791 (I) (CL:TAGBODY ~G198 (CL:COND ((NOT ~G200) (CL:GO ~G199))) (CL:SETQ I (CL:CAR ~G200)) (%PRINT-GAP STR) (CL:COND ((CL:COND ((%BODY? (CL:CDR I)) (CL:CDR (CL:CDR I)))) (CL:PROGN (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))) (%PRINT-BODY (CL:CDR (CL:CDR I)) STR INFO))) ((%REST? (CL:CDR I)) (%PRINT-REST (CL:CDR (CL:CDR I)) STR INFO)) ((%KEY? (CL:CDR I)) (CL:PROGN (%PRINT-SYMBOL (MAKE-KEYWORD (CL:CAR I)) STR INFO) (PRINC " " STR) (%LATE-PRINT (CL:CDR (CL:CDR I)) STR INFO))) (T (CL:LABELS ((~G792 (~G196) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G793 (~G197) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G196)) ~G197)) (~G793 (CL:PROGN (%LATE-PRINT (CL:CDR I) STR INFO)))))) (~G792 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G200 (CL:CDR ~G200)) (CL:GO ~G198) ~G199 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G791 NIL)))) (~G790 EXPANDED))))))) (~G789 (%PRINT-GET-ARGS (CL:CDR X) ARGDEF))) (PRINC ")" STR) (CL:LABELS ((~G794 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G794 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))
  (CL:DEFUN %PRINT-CALL? (X INFO) (CL:BLOCK %PRINT-CALL? (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((CONS? X) (CL:COND ((CL:CAR X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:COND ((LIST? (CL:CDR X)) (CL:LABELS ((~G795 (~G201) (CL:COND (~G201 ~G201) (T (CL:COND ((NOT (BUILTIN? (CL:CAR X))) (CL:PROGN (CL:COND ((FUNCTION? (SYMBOL-FUNCTION (CL:CAR X))) (FUNCTION-ARGUMENTS (CL:CAR X))))))))))) (~G795 (%GET-PRINTER-ARGUMENT-DEFINITION (CL:CAR X)))))))))))))))))
  (CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:LABELS ((~G796 (!) (CL:COND (! (CL:COND ((FUNCTION? !) (FUNCALL ! X STR INFO)) (T (%PRINT-CALL X ! STR INFO)))) (T (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO) (PRINC ")" STR) (CL:LABELS ((~G797 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G797 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))) (~G796 (%PRINT-CALL? X INFO))))))
  (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-SYMBOL-COMPONENT (X STR) (CL:BLOCK %PRINT-SYMBOL-COMPONENT (CL:BLOCK NIL (CL:COND ((SOME (CL:FUNCTION SYMBOL-CHAR-NEEDS-ESCAPING?) (STRING-LIST X)) (%PRINT-ESCAPED-SYMBOL X STR)) (T (PRINC X STR))))))
  (CL:DEFUN %PRINT-SYMBOL-PACKAGE (NAME STR) (CL:BLOCK %PRINT-SYMBOL-PACKAGE (CL:BLOCK NIL (%PRINT-SYMBOL-COMPONENT (ABBREVIATED-PACKAGE-NAME NAME) STR))))
  (CL:DEFUN INVISIBLE-PACKAGE-NAME? (X) (CL:BLOCK INVISIBLE-PACKAGE-NAME? (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G798 (~G209) (CL:COND (~G209 ~G209) (T (CL:LABELS ((~G799 (~G210) (CL:COND (~G210 ~G210) (T *ALWAYS-PRINT-PACKAGE-NAMES?*)))) (~G799 (EQ T X))))))) (~G798 (NOT X)))) (CL:PROGN (INVISIBLE-PACKAGE? (SYMBOL-PACKAGE X))))))))
  (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 RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  (CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN =-PRINT-INFO-INDENTATION (VAL ARR) (CL:BLOCK =-PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN %BODY-INDENTATION (INFO) (CL:BLOCK %BODY-INDENTATION (CL:BLOCK NIL (CL:LABELS ((~G800 (~G190) (CL:COND (~G190 ~G190) (T 1)))) (~G800 (CL:CAR (PRINT-INFO-COLUMNS INFO)))))))
  (CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN %PRINT-OBJECT (X STR INFO) (CL:BLOCK %PRINT-OBJECT (CL:BLOCK 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 %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (CL:LABELS ((~G801 (~G212) (CL:COND (~G212 (CL:PROGN (CL:LABELS ((~G802 (~G214) (CL:BLOCK NIL (CL:LABELS ((~G803 (~G213) (CL:TAGBODY ~G215 (CL:COND ((== ~G213 ~G214) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G804 (I) (CL:LABELS ((~G805 (~G216) (CL:COND (~G216 ~G216) (T (PRINC #\  STR))))) (~G805 (ZERO? I))) (%LATE-PRINT I STR INFO))) (~G804 (CL:AREF ~G212 ~G213))) (CL:SETQ ~G213 (NUMBER+ 1 ~G213)) (CL:GO ~G215)))) (~G803 0))))) (~G802 (INTEGER (CL:LENGTH ~G212))))))))) (~G801 X)) (PRINC ")" STR) (CL:LABELS ((~G806 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G806 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))
  (CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G807 (~G204) (CL:LABELS ((~G808 (I) (CL:TAGBODY ~G202 (CL:COND ((NOT ~G204) (CL:GO ~G203))) (CL:SETQ I (CL:CAR ~G204)) (CL:COND ((EQL I #\") (PRINC "\\\"" STR)) ((EQL I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G204 (CL:CDR ~G204)) (CL:GO ~G202) ~G203 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G808 NIL)))) (~G807 (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:LABELS ((~G809 (!) (CL:COND (! (CL:PROGN (CL:COND ((NOT (INVISIBLE-PACKAGE-NAME? X)) (CL:PROGN (CL:LABELS ((~G810 (~G211) (CL:COND (~G211 ~G211) (T (%PRINT-SYMBOL-PACKAGE (CL:PACKAGE-NAME !) STR))))) (~G810 (KEYWORD? X))) (PRINC #\: STR))))))))) (~G809 (CL:COND (X (CL:COND ((NOT (EQ T X)) (SYMBOL-PACKAGE X))))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
  (CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G811 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G811 (CL:COND ((CONS? (CL:CDR X)) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST (CL:FUNCTION EQ)))))))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G812 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G812 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN NUMBER-DIGIT (X) (CL:BLOCK NUMBER-DIGIT (CL:BLOCK NIL (CODE-CHAR (+ X (CL:CHAR-CODE #\0))))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- (CL:CHAR-CODE X) (CL:CHAR-CODE #\0)))))
  (CL:DEFUN %NONDECIMAL-DIGIT? (X START BASE) (CL:BLOCK %NONDECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X START (CODE-CHAR (+ (CL:CHAR-CODE START) (- BASE 10)))))))
  (CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:LABELS ((~G813 (~G217) (CL:COND ((CONS? ~G217) (%PRINT-CONS X STR INFO)) ((SYMBOL? ~G217) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G217) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G217) (PRINC X STR)) ((STRING? ~G217) (%PRINT-STRING X STR)) ((ARRAY? ~G217) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G217) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G217) (%PRINT-OBJECT X STR INFO)) (T (%ERROR "Don't know how to print object."))))) (~G813 X))))))
  (CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (CL:LABELS ((~G814 (~G191) (CL:PROGN (=-PRINT-INFO-INDENTATION (%BODY-INDENTATION INFO) INFO)) (CL:LABELS ((~G815 (~G192) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G191 INFO)) ~G192)) (~G815 (CL:PROGN (CL:LABELS ((~G816 (FIRST?) (CL:BLOCK NIL (CL:LABELS ((~G817 (~G195) (CL:LABELS ((~G818 (I) (CL:TAGBODY ~G193 (CL:COND ((NOT ~G195) (CL:GO ~G194))) (CL:SETQ I (CL:CAR ~G195)) (CL:COND (FIRST? (CL:PROGN (CL:SETQ FIRST? NIL))) (T (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))))) (%LATE-PRINT I STR INFO) (CL:SETQ ~G195 (CL:CDR ~G195)) (CL:GO ~G193) ~G194 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G818 NIL)))) (~G817 X))))) (~G816 T))))))) (~G814 (PRINT-INFO-INDENTATION INFO))))))
  (CL:DEFUN =-PRINT-INFO-COLUMNS (VAL ARR) (CL:BLOCK =-PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN PRINT-INFO-COLUMNS (ARR) (CL:BLOCK PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:AREF ARR 5))))
  (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 ((~G819 (~G188) (CL:BLOCK NIL (CL:LABELS ((~G820 (!) (CL:TAGBODY ~G189 (CL:COND ((== ! ~G188) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G189)))) (~G820 0))))) (~G819 (INTEGER (PRINT-INFO-INDENTATION INFO)))))))))))
  (CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION) (COLUMNS 'COLUMNS)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G821 (~G186) (CL:PROGN (=-AREF 'STRUCT ~G186 0) (=-AREF 'PRINT-INFO ~G186 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) NIL) (T PRETTY-PRINT?)) ~G186 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G186 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G186 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMNS 'COLUMNS) NIL) (T COLUMNS)) ~G186 5)) ~G186)) (~G821 (MAKE-ARRAY 6))))))
  (CL:DEFUN CHARRANGE? (X START END) (CL:BLOCK CHARRANGE? (CL:BLOCK NIL (RANGE? (CL:CHAR-CODE X) (CL:CHAR-CODE START) (CL:CHAR-CODE END)))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G58) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G822 (~G62) (CL:LABELS ((~G823 (C) (CL:TAGBODY ~G60 (CL:COND ((NOT ~G62) (CL:GO ~G61))) (CL:SETQ C (CL:CAR ~G62)) (CL:LABELS ((~G824 (~G59) (CL:COND (~G59 ~G59) (T (CL:RETURN-FROM NIL NIL))))) (~G824 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G62 (CL:CDR ~G62)) (CL:GO ~G60) ~G61 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G823 NIL)))) (~G822 ~G58))))))
  (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*) CL:&KEY (PRINT-INFO (MAKE-PRINT-INFO))) (CL:BLOCK LATE-PRINT (CL:BLOCK NIL (CL:LABELS ((~G825 (~G218) (CL:LABELS ((~G826 (S) (CL:LABELS ((~G827 (~G219) (CL:COND (~G218 ~G219) (T (GET-STREAM-STRING S))))) (~G827 (CL:PROGN (CL:COND ((CL:COND ((CONS? X) (CONS? (CL:CAR X)))) (CL:PROGN (%PRINT-INDENTATION S PRINT-INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) (PRINC "(" S) (%PRINT-BODY X S PRINT-INFO) (PRINC ")" S) (CL:LABELS ((~G828 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) RET)) (~G828 (CL:CAR (PRINT-INFO-COLUMNS PRINT-INFO)))))) (T (%LATE-PRINT X S PRINT-INFO))) (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (CL:COND ((NOT (FRESH-LINE? S)) (TERPRI S)))))))))) (~G826 (DEFAULT-STREAM ~G218))))) (~G825 STR)) X)))
  (CL:DEFUN NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (INTEGER (++ (* SIZE (++ (/ (-- COLUMN) SIZE))))))))
  (CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN =-STREAM-LOCATION-COLUMN (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN STREAM-LOCATION-TABSIZE (ARR) (CL:BLOCK STREAM-LOCATION-TABSIZE (CL:BLOCK NIL (CL:AREF ARR 6))))
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G829 (~G74) (CL:COND (~G74 ~G74) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G829 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X #\0 #\9))))
  (CL:DEFUN GENERIC-SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK GENERIC-SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G830 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (LIST SEQ))))) (~G830 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G831 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G832 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G833 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G834 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G835 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G836 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G837 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G838 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G839 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G840 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G841 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G842 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G843 (~G250) (CL:COND (~G250 ~G250) (T (EQL X #\^))))) (~G843 (EQL X #\#))))))) (~G842 (EQL X #\;))))))) (~G841 (EQL X #\:))))))) (~G840 (EQL X #\,))))))) (~G839 (EQL X #\`))))))) (~G838 (EQL X #\'))))))) (~G837 (EQL X #\"))))))) (~G836 (EQL X #\}))))))) (~G835 (EQL X #\{))))))) (~G834 (EQL X #\]))))))) (~G833 (EQL X #\[))))))) (~G832 (EQL X #\)))))))) (~G831 (EQL X #\())))))
  (CL:DEFUN READ-INTEGER-0 (STR V) (CL:BLOCK READ-INTEGER-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-INTEGER-0 STR (+ (* V 10) (DIGIT-NUMBER (READ-CHAR STR))))) (T V)))))
  (CL:DEFUN PEEK-DIGIT (STR) (CL:BLOCK PEEK-DIGIT (CL:BLOCK NIL (CL:LABELS ((~G844 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G844 (PEEK-CHAR STR))))))
  (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 DECIMALS-CHARS (X) (CL:BLOCK DECIMALS-CHARS (CL:BLOCK NIL (CL:LABELS ((~G845 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G845 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN INTEGER-CHARS (X) (CL:BLOCK INTEGER-CHARS (CL:BLOCK NIL (REVERSE (INTEGER-CHARS-0 (INTEGER (ABS X)))))))
  (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 ((~G846 (E) (CL:LABELS ((~G847 (S) (CL:COND ((CL:LABELS ((~G848 (~G95) (CL:COND (~G95 ~G95) (T (CL:COND ((< S E) FROM-END)))))) (~G848 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G849 (~G96) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G96)))) (~G849 S)))) (CL:BLOCK NIL (CL:LABELS ((~G850 (I) (CL:TAGBODY ~G97 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G851 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (LIST I))))) (CL:RETURN-FROM NIL !))))) (~G851 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G97)))) (~G850 S))))) (~G847 (CL:LABELS ((~G852 (~G94) (CL:COND (~G94 ~G94) (T 0)))) (~G852 START)))))) (~G846 (CL:LABELS ((~G853 (~G93) (CL:COND (~G93 ~G93) (T (-- (CL:LENGTH SEQ)))))) (~G853 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G854 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G855 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G856 (~G92) (CL:LABELS ((~G857 (I) (CL:TAGBODY ~G90 (CL:COND ((NOT ~G92) (CL:GO ~G91))) (CL:SETQ I (CL:CAR ~G92)) (CL:COND ((FUNCALL PRED I IDX) (CL:RETURN-FROM NIL I))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G92 (CL:CDR ~G92)) (CL:GO ~G90) ~G91 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G857 NIL)))) (~G856 !))))) (~G855 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G858 (~G89) (CL:LABELS ((~G859 (I) (CL:TAGBODY ~G87 (CL:COND ((NOT ~G89) (CL:GO ~G88))) (CL:SETQ I (CL:CAR ~G89)) (CL:COND ((FUNCALL PRED I) (CL:RETURN-FROM NIL I))) (CL:SETQ ~G89 (CL:CDR ~G89)) (CL:GO ~G87) ~G88 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G859 NIL)))) (~G858 !))))))) (~G854 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G860 (!) (CL:BLOCK NIL (CL:LABELS ((~G861 (~G23) (CL:LABELS ((~G862 (I) (CL:TAGBODY ~G21 (CL:COND ((NOT ~G23) (CL:GO ~G22))) (CL:SETQ I (CL:CAR ~G23)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G23 (CL:CDR ~G23)) (CL:GO ~G21) ~G22 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G862 NIL)))) (~G861 LST))))) (~G860 NIL)))))
  (CL:DEFUN =-ELT (VAL SEQ IDX) (CL:BLOCK =-ELT (CL:BLOCK NIL (%SET-ELT VAL SEQ IDX))))
  (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 (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 QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G863 (~G9) (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))))) ~G9)) (~G863 (CL:CAR (CL:CDR X)))))))
  (CL:DEFUN PRINC-NUMBER (X STR) (CL:BLOCK PRINC-NUMBER (CL:BLOCK NIL (CL:COND ((< X 0) (PRINC #\- STR))) (STREAM-PRINC (INTEGER-CHARS X) STR) (CL:LABELS ((~G864 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (DECIMALS-CHARS !) STR)))))) (~G864 (CL:MOD X 1))))))
  (CL:DEFUN NUMBER-NOT-CHARACTER? (X) (CL:BLOCK NUMBER-NOT-CHARACTER? (CL:BLOCK NIL (CL:COND ((NOT (CHARACTER? X)) (NUMBER? X))))))
  (CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G865 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G865 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G866 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G866 (PEEK-CHAR STR))))))
  (CL:DEFUN READ-INTEGER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-INTEGER (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (INTEGER (READ-INTEGER-0 STR 0)))))))
  (CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:COND ((> (CL:CHAR-CODE X) 32) (NOT (SPECIAL-CHAR? X)))))))))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G867 (~G76) (CL:COND (~G76 ~G76) (T (CL:LABELS ((~G868 (~G77) (CL:COND (~G77 ~G77) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G868 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G867 (DIGIT-CHAR? X))))))
  (CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (GENERIC-SPLIT OBJ SEQ :TEST TEST :INCLUDE? INCLUDE?))))
  (CL:DEFUN STREAM-LOCATION-ID (ARR) (CL:BLOCK STREAM-LOCATION-ID (CL:BLOCK NIL (CL:AREF ARR 3))))
  (CL:DEFUN STREAM-LOCATION-LINE (ARR) (CL:BLOCK STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
  (CL:DEFUN READ-SYMBOL (STR) (CL:BLOCK READ-SYMBOL (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:BLOCK NIL (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (F))))))) (CL:COND ((NOT (SPECIAL-CHAR? (SEEK-CHAR STR))) (CL:PROGN (F))))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G869 (~G101) (CL:LABELS ((~G870 (SEQ) (CL:TAGBODY ~G99 (CL:COND ((NOT ~G101) (CL:GO ~G100))) (CL:SETQ SEQ (CL:CAR ~G101)) (CL:LABELS ((~G871 (~G102) (CL:BLOCK NIL (CL:LABELS ((~G872 (!) (CL:TAGBODY ~G103 (CL:COND ((== ! ~G102) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G873 (~G98) (CL:COND (~G98 ~G98) (T (CL:RETURN-FROM EVERY NIL))))) (~G873 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G103)))) (~G872 0))))) (~G871 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G101 (CL:CDR ~G101)) (CL:GO ~G99) ~G100 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G870 NIL)))) (~G869 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G874 (~G75) (CL:COND (~G75 ~G75) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G874 (DECIMAL-DIGIT? C))))))))
  (CL:DEFUN STREAM-FUN-OUT (ARR) (CL:BLOCK STREAM-FUN-OUT (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G875 (~G145) (CL:LABELS ((~G876 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G877 (~G146) (CL:COND (~G146 (CL:PROGN (CL:LABELS ((~G878 (~G148) (CL:BLOCK NIL (CL:LABELS ((~G879 (~G147) (CL:TAGBODY ~G149 (CL:COND ((== ~G147 ~G148) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G880 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G880 (ELT ~G146 ~G147))) (CL:SETQ ~G147 (NUMBER+ 1 ~G147)) (CL:GO ~G149)))) (~G879 0))))) (~G878 (INTEGER (CL:LENGTH ~G146))))))))) (~G877 X))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 (CL:CHAR-CODE X)) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 STREAM-LOCATION)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE STREAM-LOCATION) 1) STREAM-LOCATION)))) (T (CL:COND ((== 9 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G876 ~G145 (STREAM-LOCATION-TRACK? ~G145) (STREAM-LOCATION-ID ~G145) (STREAM-LOCATION-LINE ~G145) (STREAM-LOCATION-COLUMN ~G145) (STREAM-LOCATION-TABSIZE ~G145))))) (~G875 STREAM-LOCATION)))))
  (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-FRESH-LINE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-FRESH-LINE (CL:BLOCK NIL (FRESH-LINE (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))))
  
negative.code: (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 ((~G892 (~G153) (CL:LABELS ((~G893 (I) (CL:TAGBODY ~G151 (CL:COND ((NOT ~G153) (CL:GO ~G152))) (CL:SETQ I (CL:CAR ~G153)) (STREAM-PRINC I STR) (CL:SETQ ~G153 (CL:CDR ~G153)) (CL:GO ~G151) ~G152 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G893 NIL)))) (~G892 X)))) ((CL:LABELS ((~G894 (~G150) (CL:COND (~G150 ~G150) (T (CHARACTER? X))))) (~G894 (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 ~G252 (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 ~G252)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G895 (~G253) (CL:COND (~G253 ~G253) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G895 (CL:COND ((CL:CDR X) (CL:LABELS ((~G896 (~G254) (CL:COND (~G254 ~G254) (T (EQL #\. (CL:CAR X)))))) (~G896 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G897 (~G255) (CL:COND (~G255 ~G255) (T (EQL #\. _))))) (~G897 (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 ((~G898 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G899 (~G251) (CL:COND (~G251 ~G251) (T "KEYWORD")))) (~G899 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G898 (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 (READ-MAKE-SYMBOL (CL:CAR (LAST X)) "TRE") NIL)) NIL)))) ((STRING? (CL:CAR X)) (READ-MAKE-SYMBOL (CL:CAR X) "TRE")) (T (CL:CAR X))))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((ERR (_) (CL:BLOCK NIL (CL:LABELS ((~G900 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G900 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-PARENS? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G901 (~G265) (CL:COND ((EQL ~G265 :PARENTHESIS-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G265 :BRACKET-OPEN) (CL:CONS 'BRACKETS (READ-CONS-SLOT STR))) ((EQL ~G265 :BRACE-OPEN) (CL:CONS 'BRACES (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G901 TOKEN)) (CL:LABELS ((~G902 (!) (CL:COND (! (CL:LABELS ((~G903 (~G267) (CL:LABELS ((~G904 (~G268) (CL:LABELS ((~G905 (TOKEN) (CL:LABELS ((~G906 (~G269) (CL:LABELS ((~G907 (PKG) (CL:LABELS ((~G908 (~G270) (CL:LABELS ((~G909 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G910 (X) (CL:LABELS ((~G911 (~G272) (CL:LABELS ((~G912 (~G273) (CL:LABELS ((~G913 (TOKEN) (CL:LABELS ((~G914 (~G274) (CL:LABELS ((~G915 (PKG) (CL:LABELS ((~G916 (~G275) (CL:LABELS ((~G917 (SYM) (CL:LABELS ((~G918 (~G266) (CL:COND (~G266 ~G266) (T (ERR "Only one value allowed after dotted cons"))))) (~G918 (%READ-CLOSING-PARENS? TOKEN))) X)) (~G917 (CL:CAR ~G275))))) (~G916 (CL:CDR ~G274))))) (~G915 (CL:CAR ~G274))))) (~G914 (CL:CDR ~G273))))) (~G913 (CL:CAR ~G273))))) (~G912 (CL:CDR ~G272))))) (~G911 (READ-TOKEN STR))))) (~G910 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G909 (CL:CAR ~G270))))) (~G908 (CL:CDR ~G269))))) (~G907 (CL:CAR ~G269))))) (~G906 (CL:CDR ~G268))))) (~G905 (CL:CAR ~G268))))) (~G904 (CL:CDR ~G267))))) (~G903 !))) (T (ERR "Closing bracket missing"))))) (~G902 (READ-TOKEN STR))))))))) (CL:LABELS ((~G919 (~G277) (CL:LABELS ((~G920 (~G278) (CL:LABELS ((~G921 (TOKEN) (CL:LABELS ((~G922 (~G279) (CL:LABELS ((~G923 (PKG) (CL:LABELS ((~G924 (~G280) (CL:LABELS ((~G925 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G925 (CL:CAR ~G280))))) (~G924 (CL:CDR ~G279))))) (~G923 (CL:CAR ~G279))))) (~G922 (CL:CDR ~G278))))) (~G921 (CL:CAR ~G278))))) (~G920 (CL:CDR ~G277))))) (~G919 (READ-TOKEN STR)))))))
  (CL:DEFUN %READ-CLOSING-PARENS? (X) (CL:BLOCK %READ-CLOSING-PARENS? (CL:BLOCK NIL (CL:LABELS ((~G926 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G927 (~G237) (CL:COND (~G237 ~G237) (T (EQL X :BRACE-CLOSE))))) (~G927 (EQL X :BRACKET-CLOSE))))))) (~G926 (EQL X :PARENTHESIS-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G928 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (LAST !)))))) (READ-SLOT-VALUE !)) (T (READ-MAKE-SYMBOL SYM PKG))))) (~G928 (SPLIT #\. SYM))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G929 (!) (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)))) (~G929 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G930 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G930 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G931 (~G222) (CL:COND (~G222 ~G222) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G931 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G932 (~G223) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G223)) (~G932 (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 ((~G933 (~G224) (CL:COND (~G224 ~G224) (T 0)))) (~G933 (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 ((~G934 (~G163) (CL:LABELS ((~G935 (S) (CL:LABELS ((~G936 (~G164) (CL:COND (~G163 ~G164) (T (GET-STREAM-STRING S))))) (~G936 (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))))) (~G935 (DEFAULT-STREAM ~G163))))) (~G934 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 ((~G937 (~G156) (CL:COND (~G156 (CL:PROGN (CL:LABELS ((~G938 (~G158) (CL:BLOCK NIL (CL:LABELS ((~G939 (~G157) (CL:TAGBODY ~G159 (CL:COND ((== ~G157 ~G158) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G940 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G940 (ELT ~G156 ~G157))) (CL:SETQ ~G157 (NUMBER+ 1 ~G157)) (CL:GO ~G159)))) (~G939 0))))) (~G938 (INTEGER (CL:LENGTH ~G156))))))))) (~G937 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 ((~G941 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G941 (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 ((~G942 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G942 (READ-CHAR STR))))))
  (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 POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G943 (!) (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) !)) (~G943 NIL)))))
  (CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G944 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G945 (L) (CL:LABELS ((~G946 (S) (CL:LABELS ((~G947 (~G54) (CL:BLOCK NIL (CL:LABELS ((~G948 (X) (CL:TAGBODY ~G55 (CL:COND ((== X ~G54) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G55)))) (~G948 0))))) (~G947 (INTEGER L))))) (~G946 (FUNCALL MAKER L))))) (~G945 (- END START)))))))) (~G944 (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 ((~G949 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G950 (L) (CL:LABELS ((~G951 (S) (CL:LABELS ((~G952 (~G50) (CL:BLOCK NIL (CL:LABELS ((~G953 (X) (CL:TAGBODY ~G51 (CL:COND ((== X ~G50) (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 ~G51)))) (~G953 0))))) (~G952 (INTEGER L))))) (~G951 (CL:MAKE-STRING 0))))) (~G950 (- END START)))))))) (~G949 (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 ((~G954 (~G52) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G52)))) (~G954 START)))) (CL:LABELS ((~G955 (Q) (CL:LABELS ((~G956 (LEN) (CL:LABELS ((~G957 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G53 (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 ~G53)))))) (~G957 (NTHCDR START SEQ))))) (~G956 (- END START))))) (~G955 (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 (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:BLOCK ARGUMENT-KEYWORD? (CL:BLOCK NIL (CL:LABELS ((~G958 (~G5) (CL:COND (~G5 ~G5) (T (CL:LABELS ((~G959 (~G6) (CL:COND (~G6 ~G6) (T (CL:LABELS ((~G960 (~G7) (CL:COND (~G7 ~G7) (T (EQ X 'CL:&KEY))))) (~G960 (EQ X 'CL:&OPTIONAL))))))) (~G959 (EQ X 'CL:&BODY))))))) (~G958 (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 ((~G961 (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 ((~G962 (!) (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 _)))) (~G962 (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))))) (~G961 NIL)))))
  (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 (~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 ((~G963 (~G175) (CL:LABELS ((~G964 (~G176) (CL:LABELS ((~G965 (A) (CL:LABELS ((~G966 (~G177) (CL:LABELS ((~G967 (K) (CL:LABELS ((~G968 (ARGDEFS) (CL:LABELS ((~G969 (KEY-ARGS) (CL:LABELS ((~G970 (NUM) (CL:LABELS ((~G971 (NO-STATIC) (CL:LABELS ((~G972 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~L; In argument expansion for ~A:~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (CL:PACKAGE-NAME (SYMBOL-PACKAGE FUN)) (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 ((~G973 (K) (CL:COND (K (CL:LABELS ((~G974 (!) (CL:LABELS ((~G975 (~G174) (CL:COND (~G174 ~G174) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (LIST (CL:CAR !)))))))) (~G975 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G974 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G973 (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 ((~G976 (~G172) (CL:COND ((EQ ~G172 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G172 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G172 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G976 (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 ((~G977 (~G173) (CL:COND (~G173 ~G173) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G977 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G978 (!) (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)))))) (~G978 (EXP-MAIN ARGDEFS ALST)))))) (~G972 NIL)))) (~G971 NIL)))) (~G970 0)))) (~G969 K)))) (~G968 A)))) (~G967 (CL:CAR ~G177))))) (~G966 (CL:CDR ~G176))))) (~G965 (CL:CAR ~G176))))) (~G964 (CL:CDR ~G175))))) (~G963 (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 ((~G979 (~G169) (CL:COND (~G169 ~G169) (T (%BODY? X))))) (~G979 (%REST? X))))))
  (CL:DEFUN %MAP-ARGS (LISTS) (CL:BLOCK %MAP-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G980 (I) (CL:LABELS ((~G981 (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)))) (~G981 (MAKE-QUEUE))))) (~G980 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 ((~G982 (~G56) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G56)))) (~G982 START)))) (CL:LABELS ((~G983 (~G57) (CL:COND ((LIST? ~G57) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G57) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G57) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G983 SEQ))))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION CHARACTER==)))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G984 (~G104) (CL:LABELS ((~G985 (~G105) (CL:LABELS ((~G986 (NUM-CDRS) (CL:LABELS ((~G987 (~G106) (CL:LABELS ((~G988 (WITHOUT-START) (CL:LABELS ((~G989 (~G108) (CL:LABELS ((~G990 (~G109) (CL:LABELS ((~G991 (NUM-CARS) (CL:LABELS ((~G992 (~G110) (CL:LABELS ((~G993 (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))))))) (~G993 (CL:CAR ~G110))))) (~G992 (CL:CDR ~G109))))) (~G991 (CL:CAR ~G109))))) (~G990 (CL:CDR ~G108))))) (~G989 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G988 (CL:CAR ~G106))))) (~G987 (CL:CDR ~G105))))) (~G986 (CL:CAR ~G105))))) (~G985 (CL:CDR ~G104))))) (~G984 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G994 (!) (CL:LABELS ((~G995 (~G113) (CL:COND (~G113 ~G113) (T (EQL #\. (ELT ! (-- (CL:LENGTH !)))))))) (~G995 (EQL #\. (ELT ! 0)))))) (~G994 (SYMBOL-NAME X))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G996 (SL) (CL:LABELS ((~G997 (L) (CL:LABELS ((~G998 (~G112) (CL:COND (~G112 ~G112) (T (NOT (DOT-POSITION SL)))))) (~G998 (== 1 L))))) (~G997 (CL:LENGTH SL))))) (~G996 (STRING-LIST (SYMBOL-NAME X)))))))
  (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 ((~G999 (~G263) (CL:COND ((EQ ~G263 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G263 :CHAR) (READ-CHAR STR)) ((EQ ~G263 :NUMBER) (CL:LABELS ((~G1000 (S) (PRINC SYM S) (READ-NUMBER S))) (~G1000 (MAKE-STRING-STREAM)))) ((EQ ~G263 :HEXNUM) (READ-HEX STR)) ((EQ ~G263 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G263 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-PARENS? TOKEN) (ERROR "Unexpected closing ~A." (CL:LABELS ((~G1001 (~G264) (CL:COND ((EQL ~G264 :PARENTHESIS-CLOSE) "parenthesis") ((EQL ~G264 :BRACE-CLOSE) "brace") ((EQL ~G264 :BRACKET-CLOSE) "bracket")))) (~G1001 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G999 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 ((~G1002 (~G232) (CL:COND (~G232 ~G232) (T (CL:LABELS ((~G1003 (~G233) (CL:COND (~G233 ~G233) (T (CL:LABELS ((~G1004 (~G234) (CL:COND (~G234 ~G234) (T (CL:LABELS ((~G1005 (~G235) (CL:COND (~G235 ~G235) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G1005 (EQL X :QUASIQUOTE-SPLICE))))))) (~G1004 (EQL X :QUASIQUOTE))))))) (~G1003 (EQL X :BACKQUOTE))))))) (~G1002 (EQL X :QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1006 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1007 (~G282) (CL:LABELS ((~G1008 (~G283) (CL:LABELS ((~G1009 (TOKEN) (CL:LABELS ((~G1010 (~G284) (CL:LABELS ((~G1011 (PKG) (CL:LABELS ((~G1012 (~G285) (CL:LABELS ((~G1013 (SYM) (READ-SLOT-VALUE (LIST ! SYM)))) (~G1013 (CL:CAR ~G285))))) (~G1012 (CL:CDR ~G284))))) (~G1011 (CL:CAR ~G284))))) (~G1010 (CL:CDR ~G283))))) (~G1009 (CL:CAR ~G283))))) (~G1008 (CL:CDR ~G282))))) (~G1007 (READ-TOKEN STR))))) (T !)))) (~G1006 (READ-CONS STR))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1014 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1015 (~G258) (CL:LABELS ((~G1016 (~G259) (CL:LABELS ((~G1017 (PKG) (CL:LABELS ((~G1018 (~G260) (CL:LABELS ((~G1019 (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 ((~G1020 (~G256) (CL:COND ((EQL ~G256 #\() :PARENTHESIS-OPEN) ((EQL ~G256 #\)) :PARENTHESIS-CLOSE) ((EQL ~G256 #\[) :BRACKET-OPEN) ((EQL ~G256 #\]) :BRACKET-CLOSE) ((EQL ~G256 #\{) :BRACE-OPEN) ((EQL ~G256 #\}) :BRACE-CLOSE) ((EQL ~G256 #\') :QUOTE) ((EQL ~G256 #\`) :BACKQUOTE) ((EQL ~G256 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G256 #\") :DBLQUOTE) ((EQL ~G256 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G256 #\#) (CL:LABELS ((~G1021 (~G257) (CL:COND ((EQL ~G257 #\\) :CHAR) ((EQL ~G257 #\x) :HEXNUM) ((EQL ~G257 #\') :FUNCTION) ((EQL ~G257 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1021 (READ-CHAR STR)))) ((EQL ~G256 -1) :EOF)))) (~G1020 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1019 (CL:CAR ~G260))))) (~G1018 (CL:CDR ~G259))))) (~G1017 (CL:CAR ~G259))))) (~G1016 (CL:CDR ~G258))))) (~G1015 !))))))) (~G1014 (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 ((~G1022 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1022 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1023 (~G165) (CL:LABELS ((~G1024 (S) (CL:LABELS ((~G1025 (~G166) (CL:COND (~G165 ~G166) (T (GET-STREAM-STRING S))))) (~G1025 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1024 (DEFAULT-STREAM ~G165))))) (~G1023 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1026 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1026 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1027 (~G160) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G160)) (~G1027 (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 ((~G1028 (!) (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)))))) (~G1028 (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 ((~G1029 (~G304) (CL:PROGN (=-AREF 'STRUCT ~G304 0) (=-AREF 'FORMAT-INFO ~G304 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G304 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G304 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G304 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G304 5)) ~G304)) (~G1029 (MAKE-ARRAY 6))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1030 (~G154) (CL:COND ((EQL ~G154 NIL) (MAKE-STRING-STREAM)) ((EQL ~G154 T) *STANDARD-OUTPUT*) (T X)))) (~G1030 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 -- (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 ((~G1031 (~G8) (CL:COND (~G8 ~G8) (T X)))) (~G1031 (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 ((~G1032 (~G144) (CL:PROGN (=-AREF 'STRUCT ~G144 0) (=-AREF 'STREAM ~G144 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G144 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G144 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G144 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G144 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G144 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G144 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G144 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G144 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G144 10)) ~G144)) (~G1032 (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 ((~G1033 (A) (CL:LABELS ((~G1034 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1035 (~G131) (CL:LABELS ((~G1036 (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))))) (~G1036 NIL)))) (~G1035 X))))) (~G1034 0)))) (~G1033 (MAKE-ARRAY (CL:LENGTH X)))))))
  (CL:DEFUN ARRAY-LIST (X) (CL:BLOCK ARRAY-LIST (CL:BLOCK NIL (CL:LABELS ((~G1037 (RESULT) (CL:LABELS ((~G1038 (~G38) (CL:BLOCK NIL (CL:LABELS ((~G1039 (!) (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)))) (~G1039 0))))) (~G1038 (INTEGER (CL:LENGTH X)))))) (~G1037 (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 ((~G1040 (L) (CL:LABELS ((~G1041 (S) (CL:BLOCK NIL (CL:LABELS ((~G1042 (I) (CL:TAGBODY ~G86 (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 ~G86)))) (~G1042 (-- L)))) S)) (~G1041 NIL)))) (~G1040 (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 ((~G1043 (~G393) (CL:COND (~G393 ~G393) (T (CL:LABELS ((~G1044 (~G394) (CL:COND (~G394 ~G394) (T (CL:LABELS ((~G1045 (~G395) (CL:COND (~G395 ~G395) (T (CL:LABELS ((~G1046 (~G396) (CL:COND (~G396 ~G396) (T (CL:LABELS ((~G1047 (~G397) (CL:COND (~G397 ~G397) (T (CL:LABELS ((~G1048 (~G398) (CL:COND (~G398 ~G398) (T (HASH-TABLE? X))))) (~G1048 (ARRAY? X))))))) (~G1047 (STRING? X))))))) (~G1046 (CHARACTER? X))))))) (~G1045 (NUMBER? X))))))) (~G1044 (EQ T X))))))) (~G1043 (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 NTH (I X) (CL:BLOCK NTH (CL:BLOCK NIL (CL:CAR (NTHCDR I X)))))
  (CL:DEFUN FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1049 (~G306) (CL:LABELS ((~G1050 (NSTR) (CL:LABELS ((~G1051 (~G307) (CL:COND (~G306 ~G307) (T (GET-STREAM-STRING NSTR))))) (~G1051 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1050 (DEFAULT-STREAM ~G306))))) (~G1049 STR)))))
  (CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1052 (~G167) (CL:LABELS ((~G1053 (S) (CL:LABELS ((~G1054 (~G168) (CL:COND (~G167 ~G168) (T (GET-STREAM-STRING S))))) (~G1054 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1053 (DEFAULT-STREAM ~G167))))) (~G1052 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 ((~G1055 (~G220) (CL:COND (~G220 ~G220) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1055 (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 ((~G1056 (~G288) (CL:LABELS ((~G1057 (~G289) (CL:LABELS ((~G1058 (TOKEN) (CL:LABELS ((~G1059 (~G290) (CL:LABELS ((~G1060 (PKG) (CL:LABELS ((~G1061 (~G291) (CL:LABELS ((~G1062 (SYM) (CL:LABELS ((~G1063 (~G287) (CL:COND ((EQL ~G287 NIL) NIL) ((EQL ~G287 :EOF) NIL) ((EQL ~G287 :PARENTHESIS-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G287 :BRACKET-OPEN) (CL:CONS 'BRACKETS (READ-CONS-SLOT STR))) ((EQL ~G287 :BRACE-OPEN) (CL:CONS 'BRACES (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1063 TOKEN)))) (~G1062 (CL:CAR ~G291))))) (~G1061 (CL:CDR ~G290))))) (~G1060 (CL:CAR ~G290))))) (~G1059 (CL:CDR ~G289))))) (~G1058 (CL:CAR ~G289))))) (~G1057 (CL:CDR ~G288))))) (~G1056 (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:COND ((NO-DOT-NOTATION? X) X) (T (CL:LABELS ((~G1064 (SL) (CL:COND ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:LABELS ((~G1065 (P) (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))))) (~G1065 (DOT-POSITION SL))))))) (~G1064 (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 ((~G1066 (~G143) (CL:PROGN (=-AREF 'STRUCT ~G143 0) (=-AREF 'STREAM-LOCATION ~G143 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G143 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G143 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G143 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G143 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G143 6)) ~G143)) (~G1066 (MAKE-ARRAY 7))))))
  (CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1067 (~G155) (CL:COND ((EQL ~G155 'INPUT) "r") ((EQL ~G155 'OUTPUT) "w") ((EQL ~G155 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1067 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 ((~G1068 (ARGS) (CL:COND (ARGS (CL:CONS (CL:APPLY FUNC ARGS) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS)))))) (~G1068 (%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 ((~G1069 (~G170) (CL:COND (~G170 ~G170) (T (%KEY? X))))) (~G1069 (%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 ((~G1070 (!) (CL:COND ((CL:LABELS ((~G1071 (~G179) (CL:COND (~G179 ~G179) (T (EQ ! 'ERROR))))) (~G1071 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1070 (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 ((~G1072 (Q) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G42 (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 ~G42)))))) (~G1072 (MAKE-QUEUE))))))
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1073 (TESTS) (CL:LABELS ((~G1074 (END) (CL:LABELS ((~G1075 (~G671) (CL:COND (~G671 ~G671) (T (ERROR "Body is missing."))))) (~G1075 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (LIST (CL:CONS T END))))) NIL)))) (~G1074 (CL:CAR (LAST TESTS)))))) (~G1073 (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 ((ATOM X) X) ((CL:APPLY *MACRO?* (LIST X)) (CL:LABELS ((~G1076 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1076 (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 ((~G1077 (~G4) (CL:COND (~G4 ~G4) (T (NOT X))))) (~G1077 (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 ((~G1078 (~G119) (CL:LABELS ((~G1079 (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))))) (~G1079 NIL)))) (~G1078 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 ((~G1080 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1080 (%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 ((~G1081 (~G221) (CL:COND (~G221 ~G221) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1081 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1082 (~G308) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1083 (~G309) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G308)) ~G309)) (~G1083 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1082 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN ELT (SEQ IDX) (CL:BLOCK ELT (CL:BLOCK NIL (CL:COND ((NOT SEQ) NIL) ((STRING? SEQ) (%ELT-STRING SEQ IDX)) ((CONS? SEQ) (NTH IDX SEQ)) (T (CL:AREF SEQ IDX))))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ANY-QUASIQUOTE? (_) (CL:BLOCK NIL (CL:LABELS ((~G1084 (~G612) (CL:COND (~G612 ~G612) (T (QUASIQUOTE-SPLICE? _))))) (~G1084 (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 ((~G1085 (~G613) (CL:COND ((ATOM ~G613) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G613) (QQ _)) ((QUASIQUOTE-SPLICE? ~G613) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1085 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1086 (~G614) (CL:COND ((QUOTE? ~G614) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G614) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1086 _)))) (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 ATOM (X) (NOT (CONS? X)))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1087 (~G3) (CL:COND (~G3 ~G3) (T (ATOM Y))))) (~G1087 (ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  (CL:DEFUN CADR (X) (CL:BLOCK CADR (CL:BLOCK NIL (CL:CAR (CL:CDR X)))))
  (CL:DEFUN GENSYM (CL:&OPTIONAL (PREFIX "~G")) (CL:LABELS ((~G1088 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1088 (MAKE-SYMBOL (STRING-CONCAT PREFIX (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1089 (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)))))))) (~G1089 (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 ((~G1090 (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)))) (~G1090 LST))))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (LIST X)))))
  (CL:DEFUN IDENTITY (X) X)
  "Section DELAYED-EXPRS"
  