anchor.diff:  (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
   NIL
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G745 (~G719) (CL:COND (~G719 ~G719) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G745 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G752 (~G726) (CL:COND (~G726 ~G726) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G752 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
   (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-ARRAY)))
   (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) (CL:FUNCTION =-AREF)))
   (CL:DEFVAR *ENVIRONMENT-PATH*)
   (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
  -(CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&REST TARGETS) (PRINT-DEFINITION `(ENV-LOAD ,PATHNAME ,@TARGETS)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGETS) *ENVIRONMENT-FILENAMES*)) (CL:COND ((CL:LABELS ((~G746 (~G720) (CL:COND (~G720 ~G720) (T (MEMBER :CL TARGETS))))) (~G746 (NOT TARGETS))) (CL:PROGN (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME)))))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
  -(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G747 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADR (CL:CAR X))))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G747 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G748 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G748 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&REST TARGETS) (PRINT-DEFINITION `(ENV-LOAD ,PATHNAME ,@TARGETS)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGETS) *ENVIRONMENT-FILENAMES*)) (CL:COND ((CL:LABELS ((~G753 (~G727) (CL:COND (~G727 ~G727) (T (MEMBER :CL TARGETS))))) (~G753 (NOT TARGETS))) (CL:PROGN (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME)))))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G754 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADR (CL:CAR X))))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G754 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G755 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G755 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
   (CL:DEFUN LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
   (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (DYNAMIC-MAP (CL:FUNCTION MAKE-LAMBDAS) X))))
   (CL:PROGN (CL:DEFUN %ERROR (MSG) (CL:BREAK (NEUTRALIZE-FORMAT-STRING MSG))) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) (CL:FUNCTION %ERROR)))
   (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
   (CL:DEFVAR *EVAL*)
   (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
  -(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G749 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G750 (~G722) (CL:COND (~G722 (CL:PROGN (CL:LABELS ((~G751 (~G724) (CL:BLOCK NIL (CL:LABELS ((~G752 (~G723) (CL:TAGBODY ~G725 (CL:COND ((== ~G723 ~G724) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G753 (I) (%PRINC I !))) (~G753 (ELT ~G722 ~G723))) (CL:SETQ ~G723 (NUMBER+ 1 ~G723)) (CL:GO ~G725)))) (~G752 0))))) (~G751 (INTEGER (CL:LENGTH ~G722))))))))) (~G750 X))) (T (CL:PRINC X !))))) (~G749 (CL:LABELS ((~G754 (~G721) (CL:COND (~G721 ~G721) (T CL:*STANDARD-OUTPUT*)))) (~G754 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G756 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G757 (~G729) (CL:COND (~G729 (CL:PROGN (CL:LABELS ((~G758 (~G731) (CL:BLOCK NIL (CL:LABELS ((~G759 (~G730) (CL:TAGBODY ~G732 (CL:COND ((== ~G730 ~G731) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G760 (I) (%PRINC I !))) (~G760 (ELT ~G729 ~G730))) (CL:SETQ ~G730 (NUMBER+ 1 ~G730)) (CL:GO ~G732)))) (~G759 0))))) (~G758 (INTEGER (CL:LENGTH ~G729))))))))) (~G757 X))) (T (CL:PRINC X !))))) (~G756 (CL:LABELS ((~G761 (~G728) (CL:COND (~G728 ~G728) (T CL:*STANDARD-OUTPUT*)))) (~G761 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
   (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
   (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
   (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
  -(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G755 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G755 (CL:READ-BYTE (CL:LABELS ((~G756 (~G726) (CL:COND (~G726 ~G726) (T CL:*STANDARD-INPUT*)))) (~G756 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G762 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G762 (CL:READ-BYTE (CL:LABELS ((~G763 (~G733) (CL:COND (~G733 ~G733) (T CL:*STANDARD-INPUT*)))) (~G763 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
   (CL:PROGN (CL:DEFUN FILE-EXISTS? (PATHNAME) (CL:COND ((CL:PROBE-FILE PATHNAME) T))) (CL:SETF (CL:GETHASH 'FILE-EXISTS? *BUILTIN-ATOMS*) (CL:FUNCTION FILE-EXISTS?)))
   (CL:DEFVAR *FUNCTIONS*)
   (CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST (CL:FUNCTION CL:EQ)))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-SOURCE)))
   (CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (ERROR "Can't set function source in the Common Lisp core.")) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION =-FUNCTION-SOURCE)))
   (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-BYTECODE)))
  -(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G757 (~G727) (CL:COND (~G727 ~G727) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G757 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
  +(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G764 (~G734) (CL:COND (~G734 ~G734) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G764 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
   (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) (CL:FUNCTION HASH-TABLE?)))
   (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) (CL:FUNCTION HREF)))
   (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) (CL:FUNCTION =-HREF)))
   (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) (CL:FUNCTION HREMOVE)))
  -(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G758 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G758 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
  -(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G759 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G759 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G765 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G765 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
  +(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G766 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G766 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
   (CL:PROGN (CL:DEFUN SYS-IMAGE-CREATE (PATHNAME FUN) (SB-EXT:SAVE-LISP-AND-DIE PATHNAME :TOPLEVEL (CL:LAMBDA NIL (CL:FUNCALL FUN)))) (CL:SETF (CL:GETHASH 'SYS-IMAGE-CREATE *BUILTIN-ATOMS*) (CL:FUNCTION SYS-IMAGE-CREATE)))
  -(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G760 (~G728) (CL:COND (~G728 ~G728) (T NIL)))) (~G760 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
  +(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G767 (~G735) (CL:COND (~G735 ~G735) (T NIL)))) (~G767 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
   (CL:PROGN (CL:DEFUN FILTER (FUN X) (CL:MAPCAR FUN X)) (CL:SETF (CL:GETHASH 'FILTER *BUILTIN-ATOMS*) (CL:FUNCTION FILTER)))
   (CL:PROGN (CL:DEFUN APPEND (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:NCONC) (CL:MAPCAR (CL:FUNCTION CL:COPY-LIST) X))) (CL:SETF (CL:GETHASH 'APPEND *BUILTIN-ATOMS*) (CL:FUNCTION APPEND)))
   (CL:DEFUN %LOAD-R (S) (CL:COND ((PEEK-CHAR S) (CL:PROGN (CL:CONS (READ S) (%LOAD-R S))))))
  -(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G761 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G761 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  -(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G762 (~G732) (CL:LABELS ((~G763 (I) (CL:TAGBODY ~G730 (CL:COND ((NOT ~G732) (CL:GO ~G731))) (CL:SETQ I (CL:CAR ~G732)) (EVAL (%EXPAND I)) (CL:SETQ ~G732 (CL:CDR ~G732)) (CL:GO ~G730) ~G731 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G763 NIL)))) (~G762 (CL:LABELS ((~G764 (S) (CL:LABELS ((~G765 (~G729) (CLOSE S) ~G729)) (~G765 (CL:BLOCK NIL (%LOAD-R S)))))) (~G764 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
  +(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G768 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G768 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  +(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G769 (~G739) (CL:LABELS ((~G770 (I) (CL:TAGBODY ~G737 (CL:COND ((NOT ~G739) (CL:GO ~G738))) (CL:SETQ I (CL:CAR ~G739)) (EVAL (%EXPAND I)) (CL:SETQ ~G739 (CL:CDR ~G739)) (CL:GO ~G737) ~G738 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G770 NIL)))) (~G769 (CL:LABELS ((~G771 (S) (CL:LABELS ((~G772 (~G736) (CLOSE S) ~G736)) (~G772 (CL:BLOCK NIL (%LOAD-R S)))))) (~G771 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
   (CL:DEFUN ENV-MACROS NIL (SYMBOL-VALUE (TRE-SYMBOL '*MACROS*)))
   (CL:PROGN (CL:DEFUN MACRO? (X) (CL:RASSOC X (ENV-MACROS) :TEST (CL:FUNCTION EQ))) (CL:SETF (CL:GETHASH 'MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION MACRO?)))
  -(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G766 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G766 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
  -(CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G767 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G767 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  +(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G773 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G773 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
  +(CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G774 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G774 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
   (CL:DEFVAR *MACROEXPAND*)
  -(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G768 (!) (CL:COND (! (CL:APPLY ! (LIST X))) (T X)))) (~G768 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
  +(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G775 (!) (CL:COND (! (CL:APPLY ! (LIST X))) (T X)))) (~G775 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
   (CL:PROGN (CL:DEFUN MACROEXPAND (X) (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (MACROEXPAND X))))) (F X (MACROEXPAND-1 X)))) (CL:SETF (CL:GETHASH 'MACROEXPAND *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND)))
   (CL:PROGN (CL:DEFUN QUIT (CL:&OPTIONAL EXIT-CODE) (SB-EXT:QUIT :UNIX-STATUS EXIT-CODE)) (CL:SETF (CL:GETHASH 'QUIT *BUILTIN-ATOMS*) (CL:FUNCTION QUIT)))
   (CL:PROGN (CL:DEFUN CODE-CHAR (X) (CL:COND ((CL:CHARACTERP X) X) (T (CL:CODE-CHAR X)))) (CL:SETF (CL:GETHASH 'CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CODE-CHAR)))
   (CL:DEFUN BITS-INTEGER (BITS) (CL:REDUCE (CL:LAMBDA (A B) (+ (* A 2) B)) BITS))
   (CL:DEFUN NUMBER (X) (CL:COND ((CHARACTER? X) (CL:CHAR-CODE X)) (T X)))
  -(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G769 (!) (CL:LABELS ((~G770 (L) (CL:LABELS ((~G771 (~G733) (CL:BLOCK NIL (CL:LABELS ((~G772 (I) (CL:TAGBODY ~G734 (CL:COND ((== I ~G733) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (NUMBER+ 1 I)) (CL:GO ~G734)))) (~G772 0))))) (~G771 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G770 NIL)))) (~G769 (NUMBER X))))
  +(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G776 (!) (CL:LABELS ((~G777 (L) (CL:LABELS ((~G778 (~G740) (CL:BLOCK NIL (CL:LABELS ((~G779 (I) (CL:TAGBODY ~G741 (CL:COND ((== I ~G740) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (NUMBER+ 1 I)) (CL:GO ~G741)))) (~G779 0))))) (~G778 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G777 NIL)))) (~G776 (NUMBER X))))
   (CL:PROGN (CL:DEFUN BIT-AND (A B) (BITS-INTEGER (CL:BIT-AND (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-AND *BUILTIN-ATOMS*) (CL:FUNCTION BIT-AND)))
   (CL:PROGN (CL:DEFUN BIT-OR (A B) (BITS-INTEGER (CL:BIT-IOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-OR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-OR)))
   (CL:PROGN (CL:DEFUN BIT-XOR (A B) (BITS-INTEGER (CL:BIT-XOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-XOR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-XOR)))
  -(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G773 (~G735) (CL:BLOCK NIL (CL:LABELS ((~G774 (N) (CL:TAGBODY ~G736 (CL:COND ((== N ~G735) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE X 2) (CL:PROGN (CL:SETQ X I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G736)))) (~G774 0))))) (~G773 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  -(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G775 (~G737) (CL:BLOCK NIL (CL:LABELS ((~G776 (N) (CL:TAGBODY ~G738 (CL:COND ((== N ~G737) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:PROGN (CL:SETQ X (* X 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G738)))) (~G776 0))))) (~G775 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
  +(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G780 (~G742) (CL:BLOCK NIL (CL:LABELS ((~G781 (N) (CL:TAGBODY ~G743 (CL:COND ((== N ~G742) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE X 2) (CL:PROGN (CL:SETQ X I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G743)))) (~G781 0))))) (~G780 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  +(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G782 (~G744) (CL:BLOCK NIL (CL:LABELS ((~G783 (N) (CL:TAGBODY ~G745 (CL:COND ((== N ~G744) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:PROGN (CL:SETQ X (* X 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G745)))) (~G783 0))))) (~G782 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
   (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY (CL:FUNCTION CL:NOT) X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) (CL:FUNCTION NOT)))
   (CL:PROGN (CL:DEFUN EQ (A B) (CL:EQ A B)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
  -(CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G777 (~G739) (CL:COND (~G739 ~G739) (T (CL:COND ((CL:COND ((CL:CHARACTERP A) (CL:CHARACTERP B))) (CL:= (CL:CHAR-CODE A) (CL:CHAR-CODE B))) ((CL:COND ((NOT (CL:CHARACTERP A) (CL:CHARACTERP B)) (CL:COND ((NUMBER? A) (NUMBER? B))))) (CL:= A B)) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((EQL (CL:CAR A) (CL:CAR B)) (EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B))))))) (~G777 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  +(CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G784 (~G746) (CL:COND (~G746 ~G746) (T (CL:COND ((CL:COND ((CL:CHARACTERP A) (CL:CHARACTERP B))) (CL:= (CL:CHAR-CODE A) (CL:CHAR-CODE B))) ((CL:COND ((NOT (CL:CHARACTERP A) (CL:CHARACTERP B)) (CL:COND ((NUMBER? A) (NUMBER? B))))) (CL:= A B)) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((EQL (CL:CAR A) (CL:CAR B)) (EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B))))))) (~G784 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
   (CL:PROGN (CL:DEFUN STRING-CONCAT (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CONCATENATE) 'CL:STRING X)) (CL:SETF (CL:GETHASH 'STRING-CONCAT *BUILTIN-ATOMS*) (CL:FUNCTION STRING-CONCAT)))
   (CL:PROGN (CL:DEFUN STRING (X) (CL:COND ((CL:NUMBERP X) (CL:FORMAT NIL "~A" X)) (T (CL:STRING X)))) (CL:SETF (CL:GETHASH 'STRING *BUILTIN-ATOMS*) (CL:FUNCTION STRING)))
   (CL:PROGN (CL:DEFUN STRING== (A B) (CL:STRING= A B)) (CL:SETF (CL:GETHASH 'STRING== *BUILTIN-ATOMS*) (CL:FUNCTION STRING==)))
  -(CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:LABELS ((~G778 (~G740) (CL:COND (~G740 ~G740) (T (ERROR "List expected instead of ~A." X))))) (~G778 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
  +(CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:LABELS ((~G785 (~G747) (CL:COND (~G747 ~G747) (T (ERROR "List expected instead of ~A." X))))) (~G785 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
   (CL:PROGN (CL:DEFUN %ELT-STRING (OBJ IDX) (CL:ELT OBJ IDX)) (CL:SETF (CL:GETHASH '%ELT-STRING *BUILTIN-ATOMS*) (CL:FUNCTION %ELT-STRING)))
   (CL:DEFVAR *SPECIAL-FORMS*)
  -(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G779 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G779 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
  +(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G786 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G786 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
   (CL:DEFUN SPECIAL-%%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ)))))))
  -(CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G780 (~G741) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G781 (~G742) (CL:PROGN (CL:SETQ *MACRO?* ~G741)) ~G742)) (~G781 (CL:PROGN (CL:LABELS ((~G782 (~G743) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G783 (~G744) (CL:PROGN (CL:SETQ *MACROCALL* ~G743)) ~G744)) (~G783 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G782 *MACROCALL*))))))) (~G780 *MACRO?*)))
  +(CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G787 (~G748) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G788 (~G749) (CL:PROGN (CL:SETQ *MACRO?* ~G748)) ~G749)) (~G788 (CL:PROGN (CL:LABELS ((~G789 (~G750) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G790 (~G751) (CL:PROGN (CL:SETQ *MACROCALL* ~G750)) ~G751)) (~G790 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G789 *MACROCALL*))))))) (~G787 *MACRO?*)))
   (CL:DEFUN MAKE-%FN-QUIET (NAME ARGS BODY) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',(CL:CONS ARGS BODY)) *FUNCTIONS*) (CL:DEFUN ,NAME ,ARGS ,@BODY)))
   NIL
   NIL
  
positive.code: ; tré Common Lisp core, generated by 'makefiles/boot-common.lisp'.
  (declaim #+sbcl(sb-ext:muffle-conditions compiler-note style-warning))
  (DEFPACKAGE "TRE-CORE" (:EXPORT "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "BACKQUOTE" "QUASIQUOTE" "QUASIQUOTE-SPLICE" "BRACKETS" "BRACES" "ACCENT-CIRCONFLEX" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK" "POW" "CHARACTER>" "CHARACTER<" "CHARACTER==" "NUMBER>" "NUMBER<" "NUMBER/" "NUMBER*" "NUMBER-" "NUMBER+" "NUMBER==" "%/" "%*" ">=" "<=" ">" "<" "==" "/" "*" "-" "%CODE-CHAR" "INTEGER" "CHARACTER?" "NUMBER?" "ARRAY?" "STRING?" "FUNCTION?" "SYMBOL?" "CONS?" "MILLISECONDS-SINCE-1970" "UNIX-SH-RM" "UNIX-SH-MKDIR" "UNIX-SH-CP" "SH" "FIND-SYMBOL" "=-SYMBOL-FUNCTION" "SYMBOL-PACKAGE" "SYMBOL-FUNCTION" "SYMBOL-VALUE" "SYMBOL-NAME" "MAKE-SYMBOL" "%ELT-STRING" "LIST-STRING" "STRING==" "STRING" "STRING-CONCAT" "EQL" "EQ" "NOT" "<<" ">>" "BIT-XOR" "BIT-OR" "BIT-AND" "CODE-CHAR" "QUIT" "MACROEXPAND" "MACROEXPAND-1" "%%MACRO?" "%%MACROCALL" "MACRO?" "LOAD" "APPEND" "FILTER" "%START-CORE" "SYS-IMAGE-CREATE" "HASHKEYS" "COPY-HASH-TABLE" "HREMOVE" "=-HREF" "HREF" "HASH-TABLE?" "MAKE-HASH-TABLE" "FUNCTION-BYTECODE" "=-FUNCTION-SOURCE" "FUNCTION-SOURCE" "FILE-EXISTS?" "%READ-CHAR" "%FCLOSE" "%FOPEN" "%FORCE-OUTPUT" "%PRINC" "EVAL" "%ERROR" "ENV-LOAD" "=-AREF" "MAKE-ARRAY" "BUILTIN?" "%FN-QUIET" "%FN" "%DEFVAR" "%DEFMACRO" "?" "*UNIVERSE*" "*VARIABLES*" "*FUNCTIONS*" "*ENVIRONMENT-PATH*" "*ENVIRONMENT-FILENAMES*" "*MACROEXPAND*" "*QUASIQUOTE-EXPAND*" "*DOT-EXPAND*" "*PACKAGE*" "*KEYWORD-PACKAGE*" "*POINTER-SIZE*" "*LAUNCHFILE*" "*ASSERT?*" "*TARGETS*" "*ENDIANESS*" "*CPU-TYPE*" "*LIBC-PATH*" "*RAND-MAX*" "*EVAL*" "CONS?" "SYMBOL?" "FUNCTION?" "STRING?" "ARRAY?" "NUMBER?" "CHARACTER?" "INTEGER" "%CODE-CHAR" "-" "*" "/" "==" "<" ">" "<=" ">=" "%*" "%/" "NUMBER==" "NUMBER+" "NUMBER-" "NUMBER*" "NUMBER/" "NUMBER<" "NUMBER>" "CHARACTER==" "CHARACTER<" "CHARACTER>" "POW") (:IMPORT-FROM "CL" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK"))
  (DEFPACKAGE "TRE" (:USE "TRE-CORE"))
  (CL:IN-PACKAGE :TRE-CORE)
  NIL
  
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"
  