anchor.diff:  (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFUN TRE-SYMBOL (X) (CL:INTERN (SYMBOL-NAME X) "TRE"))
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G775 (~G750) (CL:COND (~G750 ~G750) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G775 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G780 (~G754) (CL:COND (~G754 ~G754) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G780 (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 ((~G776 (~G751) (CL:COND (~G751 ~G751) (T (MEMBER :CL TARGETS))))) (~G776 (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 ((~G777 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G777 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G778 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G778 (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 ((~G781 (~G755) (CL:COND (~G755 ~G755) (T (MEMBER :CL TARGETS))))) (~G781 (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 ((~G782 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G782 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G783 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G783 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
   (CL:DEFUN LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (CL:ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
   (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((CL:ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (CL:MAPCAR (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 ((~G779 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G780 (~G753) (CL:COND (~G753 (CL:PROGN (CL:LABELS ((~G781 (~G755) (CL:BLOCK NIL (CL:LABELS ((~G782 (~G754) (CL:TAGBODY ~G756 (CL:COND ((== ~G754 ~G755) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G783 (I) (%PRINC I !))) (~G783 (ELT ~G753 ~G754))) (CL:SETQ ~G754 (NUMBER+ 1 ~G754)) (CL:GO ~G756)))) (~G782 0))))) (~G781 (CL:LENGTH ~G753)))))))) (~G780 X))) (T (CL:PRINC X !))))) (~G779 (CL:LABELS ((~G784 (~G752) (CL:COND (~G752 ~G752) (T CL:*STANDARD-OUTPUT*)))) (~G784 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G784 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G785 (~G757) (CL:COND (~G757 (CL:PROGN (CL:LABELS ((~G786 (~G759) (CL:BLOCK NIL (CL:LABELS ((~G787 (~G758) (CL:TAGBODY ~G760 (CL:COND ((== ~G758 ~G759) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G788 (I) (%PRINC I !))) (~G788 (ELT ~G757 ~G758))) (CL:SETQ ~G758 (NUMBER+ 1 ~G758)) (CL:GO ~G760)))) (~G787 0))))) (~G786 (CL:LENGTH ~G757)))))))) (~G785 X))) (T (CL:PRINC X !))))) (~G784 (CL:LABELS ((~G789 (~G756) (CL:COND (~G756 ~G756) (T CL:*STANDARD-OUTPUT*)))) (~G789 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 ((~G785 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G785 (CL:READ-BYTE (CL:LABELS ((~G786 (~G757) (CL:COND (~G757 ~G757) (T CL:*STANDARD-INPUT*)))) (~G786 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G790 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G790 (CL:READ-BYTE (CL:LABELS ((~G791 (~G761) (CL:COND (~G761 ~G761) (T CL:*STANDARD-INPUT*)))) (~G791 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-NATIVE (X) X) (CL:SETF (CL:GETHASH 'FUNCTION-NATIVE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-NATIVE)))
   (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 ((~G787 (~G758) (CL:COND (~G758 ~G758) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G787 (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 ((~G792 (~G762) (CL:COND (~G762 ~G762) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G792 (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 ((~G788 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G788 (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 ((~G789 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G789 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G793 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G793 (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 ((~G794 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G794 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 ((~G790 (~G759) (CL:COND (~G759 ~G759) (T NIL)))) (~G790 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 ((~G795 (~G763) (CL:COND (~G763 ~G763) (T NIL)))) (~G795 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 ((~G791 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G791 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  -(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G792 (~G763) (CL:LABELS ((~G793 (I) (CL:TAGBODY ~G761 (CL:COND ((NOT ~G763) (CL:GO ~G762))) (CL:SETQ I (CL:CAR ~G763)) (EVAL (%EXPAND I)) (CL:SETQ ~G763 (CL:CDR ~G763)) (CL:GO ~G761) ~G762 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G793 NIL)))) (~G792 (CL:LABELS ((~G794 (S) (CL:LABELS ((~G795 (~G760) (CLOSE S) ~G760)) (~G795 (CL:BLOCK NIL (%LOAD-R S)))))) (~G794 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
  +(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G796 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G796 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  +(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G797 (~G767) (CL:LABELS ((~G798 (I) (CL:TAGBODY ~G765 (CL:COND ((NOT ~G767) (CL:GO ~G766))) (CL:SETQ I (CL:CAR ~G767)) (EVAL (%EXPAND I)) (CL:SETQ ~G767 (CL:CDR ~G767)) (CL:GO ~G765) ~G766 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G798 NIL)))) (~G797 (CL:LABELS ((~G799 (S) (CL:LABELS ((~G800 (~G764) (CLOSE S) ~G764)) (~G800 (CL:BLOCK NIL (%LOAD-R S)))))) (~G799 (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 ((~G796 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G796 (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 ((~G797 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G797 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  +(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G801 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G801 (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 ((~G802 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G802 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
   (CL:DEFVAR *MACROEXPAND*)
  -(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G798 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G798 (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 ((~G803 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G803 (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 NANOTIME NIL 0) (CL:SETF (CL:GETHASH 'NANOTIME *BUILTIN-ATOMS*) (CL:FUNCTION NANOTIME)))
   (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 ((~G799 (!) (CL:LABELS ((~G800 (L) (CL:LABELS ((~G801 (~G764) (CL:BLOCK NIL (CL:LABELS ((~G802 (I) (CL:TAGBODY ~G765 (CL:COND ((== I ~G764) (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 ~G765)))) (~G802 0))))) (~G801 32)) (CL:COERCE L 'CL:BIT-VECTOR))) (~G800 NIL)))) (~G799 (NUMBER X))))
  +(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G804 (!) (CL:LABELS ((~G805 (L) (CL:LABELS ((~G806 (~G768) (CL:BLOCK NIL (CL:LABELS ((~G807 (I) (CL:TAGBODY ~G769 (CL:COND ((== I ~G768) (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 ~G769)))) (~G807 0))))) (~G806 32)) (CL:COERCE L 'CL:BIT-VECTOR))) (~G805 NIL)))) (~G804 (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 ((~G803 (~G766) (CL:BLOCK NIL (CL:LABELS ((~G804 (N) (CL:TAGBODY ~G767 (CL:COND ((== N ~G766) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G767)))) (~G804 0))))) (~G803 BITS))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  -(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G805 (~G768) (CL:BLOCK NIL (CL:LABELS ((~G806 (N) (CL:TAGBODY ~G769 (CL:COND ((== N ~G768) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G769)))) (~G806 0))))) (~G805 BITS))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
  +(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G808 (~G770) (CL:BLOCK NIL (CL:LABELS ((~G809 (N) (CL:TAGBODY ~G771 (CL:COND ((== N ~G770) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G771)))) (~G809 0))))) (~G808 BITS))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  +(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G810 (~G772) (CL:BLOCK NIL (CL:LABELS ((~G811 (N) (CL:TAGBODY ~G773 (CL:COND ((== N ~G772) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G773)))) (~G811 0))))) (~G810 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 ((~G807 (~G770) (CL:COND (~G770 ~G770) (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))))))) (~G807 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  +(CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G812 (~G774) (CL:COND (~G774 ~G774) (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))))))) (~G812 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
   (CL:PROGN (CL:DEFUN ELT (SEQ IDX) (CL:COND (SEQ (CL:COND ((CL:< IDX (CL:LENGTH SEQ)) (CL:ELT SEQ IDX)))))) (CL:SETF (CL:GETHASH 'ELT *BUILTIN-ATOMS*) (CL:FUNCTION ELT)))
   (CL:PROGN (CL:DEFUN %SET-ELT (OBJ SEQ IDX) (CL:SETF (CL:ELT SEQ IDX) OBJ)) (CL:SETF (CL:GETHASH '%SET-ELT *BUILTIN-ATOMS*) (CL:FUNCTION %SET-ELT)))
   (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: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 ((~G813 (~G775) (CL:COND (~G775 ~G775) (T (ERROR "List expected instead of ~A." X))))) (~G813 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
   (CL:DEFVAR *SPECIAL-FORMS*)
  -(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G808 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G808 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
  +(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G814 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G814 (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 ((~G809 (~G771) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G810 (~G772) (CL:PROGN (CL:SETQ *MACRO?* ~G771)) ~G772)) (~G810 (CL:PROGN (CL:LABELS ((~G811 (~G773) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G812 (~G774) (CL:PROGN (CL:SETQ *MACROCALL* ~G773)) ~G774)) (~G812 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G811 *MACROCALL*))))))) (~G809 *MACRO?*)))
  +(CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G815 (~G776) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G816 (~G777) (CL:PROGN (CL:SETQ *MACRO?* ~G776)) ~G777)) (~G816 (CL:PROGN (CL:LABELS ((~G817 (~G778) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G818 (~G779) (CL:PROGN (CL:SETQ *MACROCALL* ~G778)) ~G779)) (~G818 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G817 *MACROCALL*))))))) (~G815 *MACRO?*)))
   (CL:DEFUN MAKE-%DEFUN-QUIET (NAME ARGS BODY) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',(CL:CONS ARGS BODY)) *FUNCTIONS*) (CL:DEFUN ,NAME ,ARGS ,@BODY)))
   (CL:DEFVAR *KEYWORD-PACKAGE*)
   (CL:PROGN (CL:DEFUN MAKE-SYMBOL (X CL:&OPTIONAL (PACKAGE NIL)) (CL:INTERN X (CL:COND ((CL:NOT PACKAGE) "TRE") ((CL:PACKAGEP PACKAGE) (CL:PACKAGE-NAME PACKAGE)) ((CL:SYMBOLP PACKAGE) (CL:SYMBOL-NAME PACKAGE)) (T PACKAGE)))) (CL:SETF (CL:GETHASH 'MAKE-SYMBOL *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-SYMBOL)))
  
positive.code: (CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
  (CL:DEFUN $ (CL:&REST ARGS) (CL:BLOCK $ (CL:BLOCK NIL (MAKE-SYMBOL (CL:APPLY (CL:FUNCTION +) (CL:MAPCAR (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 ((~G939 (~G173) (CL:COND (~G173 ~G173) (T (CL:LABELS ((~G940 (~G174) (CL:COND (~G174 ~G174) (T (CL:LABELS ((~G941 (~G175) (CL:COND (~G175 ~G175) (T (EQ X 'CL:&KEY))))) (~G941 (EQ X 'CL:&OPTIONAL))))))) (~G940 (EQ X 'CL:&BODY))))))) (~G939 (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 ((~G942 (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 ((~G943 (!) (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 _)))) (~G943 (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))))) (~G942 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 (~G110) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G110))))
  (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 ((~G944 (~G179) (CL:LABELS ((~G945 (~G180) (CL:LABELS ((~G946 (A) (CL:LABELS ((~G947 (~G181) (CL:LABELS ((~G948 (K) (CL:LABELS ((~G949 (ARGDEFS) (CL:LABELS ((~G950 (KEY-ARGS) (CL:LABELS ((~G951 (NUM) (CL:LABELS ((~G952 (NO-STATIC) (CL:LABELS ((~G953 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~L; In argument expansion for ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL." (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G954 (K) (CL:COND (K (CL:LABELS ((~G955 (!) (CL:LABELS ((~G956 (~G178) (CL:COND (~G178 ~G178) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (CL:LIST (CL:CAR !)))))))) (~G956 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G955 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G954 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G957 (~G176) (CL:COND ((EQ ~G176 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G176 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G176 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G957 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "Too many arguments. Maximum is ~A, but ~A more given." (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G958 (~G177) (CL:COND (~G177 ~G177) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G958 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G959 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G959 (EXP-MAIN ARGDEFS ALST)))))) (~G953 NIL)))) (~G952 NIL)))) (~G951 0)))) (~G950 K)))) (~G949 A)))) (~G948 (CL:CAR ~G181))))) (~G947 (CL:CDR ~G180))))) (~G946 (CL:CAR ~G180))))) (~G945 (CL:CDR ~G179))))) (~G944 (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 ((~G960 (~G170) (CL:COND (~G170 ~G170) (T (%BODY? X))))) (~G960 (%REST? X))))))
  (CL:DEFUN ++ (X) (NUMBER+ X 1))
  (CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING X)))))
  (CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G961 (~G50) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G50)))) (~G961 START)))) (CL:LABELS ((~G962 (~G51) (CL:COND ((CONS? ~G51) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G51) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G51) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G962 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G963 (~G100) (CL:LABELS ((~G964 (~G101) (CL:LABELS ((~G965 (NUM-CDRS) (CL:LABELS ((~G966 (~G102) (CL:LABELS ((~G967 (WITHOUT-START) (CL:LABELS ((~G968 (~G104) (CL:LABELS ((~G969 (~G105) (CL:LABELS ((~G970 (NUM-CARS) (CL:LABELS ((~G971 (~G106) (CL:LABELS ((~G972 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G972 (CL:CAR ~G106))))) (~G971 (CL:CDR ~G105))))) (~G970 (CL:CAR ~G105))))) (~G969 (CL:CDR ~G104))))) (~G968 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G967 (CL:CAR ~G102))))) (~G966 (CL:CDR ~G101))))) (~G965 (CL:CAR ~G101))))) (~G964 (CL:CDR ~G100))))) (~G963 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G973 (SL) (CL:LABELS ((~G974 (~G109) (CL:COND (~G109 ~G109) (T (EQL #\. (CL:CAR (CL:LAST SL))))))) (~G974 (EQL #\. (CL:CAR SL)))))) (~G973 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G975 (SL) (CL:LABELS ((~G976 (L) (CL:LABELS ((~G977 (P) (CL:LABELS ((~G978 (~G108) (CL:COND (~G108 ~G108) (T (NOT P))))) (~G978 (== 1 L))))) (~G977 (DOT-POSITION SL))))) (~G976 (CL:LENGTH SL))))) (~G975 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION CHARACTER==)))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((EQL #\; (PEEK-CHAR STR)) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR)))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G979 (~G267) (CL:COND ((EQ ~G267 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G267 :CHAR) (READ-CHAR STR)) ((EQ ~G267 :NUMBER) (CL:LABELS ((~G980 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G980 (MAKE-STRING-STREAM)))) ((EQ ~G267 :HEXNUM) (READ-HEX STR)) ((EQ ~G267 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G267 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G981 (~G268) (CL:COND ((EQUAL ~G268 :BRACKET-CLOSE) "round") ((EQUAL ~G268 :CURLY-BRACKET-CLOSE) "curly") ((EQUAL ~G268 :SQUARE-BRACKET-CLOSE) "square")))) (~G981 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G979 TOKEN)))))
  (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST (MAKE-SYMBOL (SYMBOL-NAME TOKEN)) (READ-EXPR STR)))))
  (CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G982 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G983 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G984 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G985 (~G240) (CL:COND (~G240 ~G240) (T (EQ X :ACCENT-CIRCONFLEX))))) (~G985 (EQ X :QUASIQUOTE-SPLICE))))))) (~G984 (EQ X :QUASIQUOTE))))))) (~G983 (EQ X :BACKQUOTE))))))) (~G982 (EQ X :QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G986 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G987 (~G286) (CL:LABELS ((~G988 (~G287) (CL:LABELS ((~G989 (TOKEN) (CL:LABELS ((~G990 (~G288) (CL:LABELS ((~G991 (PKG) (CL:LABELS ((~G992 (~G289) (CL:LABELS ((~G993 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G993 (CL:CAR ~G289))))) (~G992 (CL:CDR ~G288))))) (~G991 (CL:CAR ~G288))))) (~G990 (CL:CDR ~G287))))) (~G989 (CL:CAR ~G287))))) (~G988 (CL:CDR ~G286))))) (~G987 (READ-TOKEN STR))))) (T !)))) (~G986 (READ-CONS STR))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G994 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G995 (~G263) (CL:LABELS ((~G996 (~G264) (CL:LABELS ((~G997 (PKG) (CL:LABELS ((~G998 (~G265) (CL:LABELS ((~G999 (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 ((~G1000 (~G261) (CL:COND ((EQUAL ~G261 #\() :BRACKET-OPEN) ((EQUAL ~G261 #\)) :BRACKET-CLOSE) ((EQUAL ~G261 #\[) :SQUARE-BRACKET-OPEN) ((EQUAL ~G261 #\]) :SQUARE-BRACKET-CLOSE) ((EQUAL ~G261 #\{) :CURLY-BRACKET-OPEN) ((EQUAL ~G261 #\}) :CURLY-BRACKET-CLOSE) ((EQUAL ~G261 #\') :QUOTE) ((EQUAL ~G261 #\`) :BACKQUOTE) ((EQUAL ~G261 #\^) :ACCENT-CIRCONFLEX) ((EQUAL ~G261 #\") :DBLQUOTE) ((EQUAL ~G261 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQUAL ~G261 #\#) (CL:LABELS ((~G1001 (~G262) (CL:COND ((EQUAL ~G262 #\\) :CHAR) ((EQUAL ~G262 #\x) :HEXNUM) ((EQUAL ~G262 #\') :FUNCTION) ((EQUAL ~G262 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1001 (READ-CHAR STR)))) ((EQUAL ~G261 -1) :EOF)))) (~G1000 (READ-CHAR STR))))))) PKG SYM))) (~G999 (CL:CAR ~G265))))) (~G998 (CL:CDR ~G264))))) (~G997 (CL:CAR ~G264))))) (~G996 (CL:CDR ~G263))))) (~G995 !))))))) (~G994 (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 ((~G1002 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1002 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1003 (~G155) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G155)) (~G1003 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1004 (~G166) (CL:LABELS ((~G1005 (S) (CL:LABELS ((~G1006 (~G167) (CL:COND (~G166 ~G167) (T (GET-STREAM-STRING S))))) (~G1006 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1005 (DEFAULT-STREAM ~G166))))) (~G1004 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1007 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1007 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1008 (~G149) (CL:COND ((EQ ~G149 NIL) (MAKE-STRING-STREAM)) ((EQ ~G149 T) *STANDARD-OUTPUT*) (T X)))) (~G1008 X)))))
  (CL:DEFUN -- (X) (NUMBER- X 1))
  (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 ((~G1009 (~G140) (CL:PROGN (=-AREF 'STRUCT ~G140 0) (=-AREF 'STREAM ~G140 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G140 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G140 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G140 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G140 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G140 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G140 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G140 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G140 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G140 10)) ~G140)) (~G1009 (MAKE-ARRAY 11))))))
  (CL:DEFUN %MACROEXPAND-BACKQUOTE (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND-BACKQUOTE (CL:CAR X)) (%MACROEXPAND-BACKQUOTE (CL:CDR X))))))
  (CL:DEFUN MAKE-STANDARD-STREAM NIL (CL:BLOCK MAKE-STANDARD-STREAM (CL:BLOCK NIL (MAKE-STREAM :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR NIL))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C NIL)) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF NIL)))))))
  (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
  (CL:DEFUN MAPCAN (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAN (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION NCONC) (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC LISTS)))))
  (CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1010 (L) (CL:LABELS ((~G1011 (S) (CL:BLOCK NIL (CL:LABELS ((~G1012 (I) (CL:TAGBODY ~G80 (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 ~G80)))) (~G1012 (-- L)))) S)) (~G1011 NIL)))) (~G1010 (CL:LENGTH X))))))
  (CL:DEFUN BACKQUOTE? (X) (CL:BLOCK BACKQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'BACKQUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN QUOTE? (X) (CL:BLOCK QUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:QUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN QUASIQUOTE-SPLICE? (X) (CL:BLOCK QUASIQUOTE-SPLICE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE-SPLICE (CL:CAR X)) X)))))))
  (CL:DEFUN QUASIQUOTE? (X) (CL:BLOCK QUASIQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN ANY-QUASIQUOTE? (X) (CL:COND ((CONS? X) (CL:COND ((EQ (CL:CAR X) 'QUASIQUOTE) T) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) T)))))
  (CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1013 (~G407) (CL:COND (~G407 ~G407) (T (CL:LABELS ((~G1014 (~G408) (CL:COND (~G408 ~G408) (T (CL:LABELS ((~G1015 (~G409) (CL:COND (~G409 ~G409) (T (CL:LABELS ((~G1016 (~G410) (CL:COND (~G410 ~G410) (T (CL:LABELS ((~G1017 (~G411) (CL:COND (~G411 ~G411) (T (CL:LABELS ((~G1018 (~G412) (CL:COND (~G412 ~G412) (T (HASH-TABLE? X))))) (~G1018 (ARRAY? X))))))) (~G1017 (STRING? X))))))) (~G1016 (CHARACTER? X))))))) (~G1015 (NUMBER? X))))))) (~G1014 (EQ T X))))))) (~G1013 (NOT X))))))
  (CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1019 (~G168) (CL:LABELS ((~G1020 (S) (CL:LABELS ((~G1021 (~G169) (CL:COND (~G168 ~G169) (T (GET-STREAM-STRING S))))) (~G1021 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1020 (DEFAULT-STREAM ~G168))))) (~G1019 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 ((~G1022 (~G225) (CL:COND (~G225 ~G225) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1022 (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 ((~G1023 (~G292) (CL:LABELS ((~G1024 (~G293) (CL:LABELS ((~G1025 (TOKEN) (CL:LABELS ((~G1026 (~G294) (CL:LABELS ((~G1027 (PKG) (CL:LABELS ((~G1028 (~G295) (CL:LABELS ((~G1029 (SYM) (CL:LABELS ((~G1030 (~G291) (CL:COND ((EQUAL ~G291 NIL) NIL) ((EQUAL ~G291 :EOF) NIL) ((EQUAL ~G291 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQUAL ~G291 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQUAL ~G291 :CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1030 TOKEN)))) (~G1029 (CL:CAR ~G295))))) (~G1028 (CL:CDR ~G294))))) (~G1027 (CL:CAR ~G294))))) (~G1026 (CL:CDR ~G293))))) (~G1025 (CL:CAR ~G293))))) (~G1024 (CL:CDR ~G292))))) (~G1023 (READ-TOKEN STR))))))
  (CL:DEFUN SEEK-CHAR (STR) (CL:BLOCK SEEK-CHAR (CL:BLOCK NIL (SKIP-SPACES STR) (PEEK-CHAR STR))))
  (CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1031 (SL) (CL:LABELS ((~G1032 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1032 (DOT-POSITION SL))))) (~G1031 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
  (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION))) (CL:BLOCK MAKE-STREAM-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR (STREAM-HANDLE _)))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C (STREAM-HANDLE STR))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF (STREAM-HANDLE _))))))))
  (CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1033 (~G139) (CL:PROGN (=-AREF 'STRUCT ~G139 0) (=-AREF 'STREAM-LOCATION ~G139 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G139 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G139 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G139 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G139 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G139 6)) ~G139)) (~G1033 (MAKE-ARRAY 7))))))
  (CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1034 (~G150) (CL:COND ((EQUAL ~G150 'INPUT) "r") ((EQUAL ~G150 'OUTPUT) "w") ((EQUAL ~G150 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1034 DIRECTION)))))
  (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  (CL:DEFUN CDRLIST (~G111) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G111))))
  (CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1035 (~G171) (CL:COND (~G171 ~G171) (T (%KEY? X))))) (~G1035 (%REST-OR-%BODY? X))))))
  (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1036 (!) (CL:COND ((CL:LABELS ((~G1037 (~G183) (CL:COND (~G183 ~G183) (T (EQ ! 'ERROR))))) (~G1037 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1036 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
  (CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:CONS (COPY-HEAD X SIZE) (GROUP (CL:NTHCDR SIZE X) SIZE)))))))
  (CL:DEFVAR *STANDARD-OUTPUT*)
  (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1038 (TESTS) (CL:LABELS ((~G1039 (END) (CL:LABELS ((~G1040 (~G698) (CL:COND (~G698 ~G698) (T (ERROR "Body is missing."))))) (~G1040 BODY)) (CL:CONS 'CL:COND (APPEND (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END))))) NIL)))) (~G1039 (CL:CAR (CL:LAST TESTS)))))) (~G1038 (GROUP BODY 2))))))
  (CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1041 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1041 (CL:APPLY *MACROCALL* (CL:LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1042 (~G115) (CL:LABELS ((~G1043 (I) (CL:TAGBODY ~G113 (CL:COND ((NOT ~G115) (CL:GO ~G114))) (CL:SETQ I (CL:CAR ~G115)) (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 ~G115 (CL:CDR ~G115)) (CL:GO ~G113) ~G114 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1043 NIL)))) (~G1042 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 ((~G1044 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1044 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  (CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X)))) (T X)))))
  (CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (CL:COND ((SEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1045 (~G226) (CL:COND (~G226 ~G226) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1045 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1046 (~G310) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1047 (~G311) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G310)) ~G311)) (~G1047 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1046 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1048 (~G635) (CL:COND ((CL:ATOM ~G635) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G635) (QQ _)) ((QUASIQUOTE-SPLICE? ~G635) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1048 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1049 (~G636) (CL:COND ((QUOTE? ~G636) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G636) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1049 _)))) (WALK (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (DISP _)) (T (CL:CONS (WALK (DISP (CL:CAR _))) (WALK (CL:CDR _)))))))) (CL:CAR (WALK (CL:LIST X)))))))
  (CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((EQL _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1050 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1050 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  (CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  (CL:DEFUN GENSYM NIL (CL:LABELS ((~G1051 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1051 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1052 (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)))))))) (~G1052 (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 ((~G1053 (I) (CL:TAGBODY ~G9 (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 ~G9)))) (~G1053 LST))))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *DEFINITION-PRINTER*)
  
negative.code: (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 ((~G820 (~G68) (CL:COND (~G68 ~G68) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G820 (%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 ((~G821 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G821 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G52) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G822 (~G56) (CL:LABELS ((~G823 (C) (CL:TAGBODY ~G54 (CL:COND ((NOT ~G56) (CL:GO ~G55))) (CL:SETQ C (CL:CAR ~G56)) (CL:LABELS ((~G824 (~G53) (CL:COND (~G53 ~G53) (T (CL:RETURN-FROM NIL NIL))))) (~G824 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G56 (CL:CDR ~G56)) (CL:GO ~G54) ~G55 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G823 NIL)))) (~G822 ~G52))))))
  (CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:LABELS ((~G825 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G826 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G827 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G828 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G829 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G830 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G831 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G832 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G833 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G834 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G835 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G836 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G837 (~G255) (CL:COND (~G255 ~G255) (T (CHARACTER== X #\^))))) (~G837 (CHARACTER== X #\#))))))) (~G836 (CHARACTER== X #\;))))))) (~G835 (CHARACTER== X #\:))))))) (~G834 (CHARACTER== X #\,))))))) (~G833 (CHARACTER== X #\`))))))) (~G832 (CHARACTER== X #\'))))))) (~G831 (CHARACTER== X #\"))))))) (~G830 (CHARACTER== X #\}))))))) (~G829 (CHARACTER== X #\{))))))) (~G828 (CHARACTER== X #\]))))))) (~G827 (CHARACTER== X #\[))))))) (~G826 (CHARACTER== X #\)))))))) (~G825 (CHARACTER== 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 ((~G838 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G838 (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 ((~G839 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G839 (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 ((~G840 (E) (CL:LABELS ((~G841 (S) (CL:COND ((CL:LABELS ((~G842 (~G91) (CL:COND (~G91 ~G91) (T (CL:COND ((< S E) FROM-END)))))) (~G842 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G843 (~G92) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G92)))) (~G843 S)))) (CL:BLOCK NIL (CL:LABELS ((~G844 (I) (CL:TAGBODY ~G93 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G845 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G845 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G93)))) (~G844 S))))) (~G841 (CL:LABELS ((~G846 (~G90) (CL:COND (~G90 ~G90) (T 0)))) (~G846 START)))))) (~G840 (CL:LABELS ((~G847 (~G89) (CL:COND (~G89 ~G89) (T (-- (CL:LENGTH SEQ)))))) (~G847 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G848 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G849 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G850 (~G88) (CL:LABELS ((~G851 (!) (CL:TAGBODY ~G86 (CL:COND ((NOT ~G88) (CL:GO ~G87))) (CL:SETQ ! (CL:CAR ~G88)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G88 (CL:CDR ~G88)) (CL:GO ~G86) ~G87 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G851 NIL)))) (~G850 !))))) (~G849 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G852 (~G85) (CL:LABELS ((~G853 (!) (CL:TAGBODY ~G83 (CL:COND ((NOT ~G85) (CL:GO ~G84))) (CL:SETQ ! (CL:CAR ~G85)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G85 (CL:CDR ~G85)) (CL:GO ~G83) ~G84 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G853 NIL)))) (~G852 !))))))) (~G848 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G854 (!) (CL:BLOCK NIL (CL:LABELS ((~G855 (~G27) (CL:LABELS ((~G856 (I) (CL:TAGBODY ~G25 (CL:COND ((NOT ~G27) (CL:GO ~G26))) (CL:SETQ I (CL:CAR ~G27)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G27 (CL:CDR ~G27)) (CL:GO ~G25) ~G26 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G856 NIL)))) (~G855 LST))))) (~G854 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G857 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G857 (CL:CAR LSTS)))))))))
  (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 (CL:ATOM SEQ) START END) (%FIND-IF-LIST PRED SEQ FROM-END WITH-INDEX)) (T (%FIND-IF-SEQUENCE PRED SEQ START END FROM-END WITH-INDEX))))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G858 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G858 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G859 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G859 (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 ((~G860 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (DECIMALS-CHARS !) STR)))))) (~G860 (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 ((~G861 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G861 (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 ((~G862 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G862 (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 ((~G863 (~G70) (CL:COND (~G70 ~G70) (T (CL:LABELS ((~G864 (~G71) (CL:COND (~G71 ~G71) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G864 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G863 (DIGIT-CHAR? X))))))
  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CODE-CHAR (- (+ (CL:CHAR-CODE C) (CL:CHAR-CODE #\A)) (CL:CHAR-CODE #\a)))) (T C)))))
  (CL:DEFUN 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: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 ((~G865 (~G97) (CL:LABELS ((~G866 (SEQ) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ SEQ (CL:CAR ~G97)) (CL:LABELS ((~G867 (~G98) (CL:BLOCK NIL (CL:LABELS ((~G868 (!) (CL:TAGBODY ~G99 (CL:COND ((== ! ~G98) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G869 (~G94) (CL:COND (~G94 ~G94) (T (CL:RETURN-FROM EVERY NIL))))) (~G869 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G99)))) (~G868 0))))) (~G867 (CL:LENGTH SEQ))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G866 NIL)))) (~G865 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G870 (~G69) (CL:COND (~G69 ~G69) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G870 (DECIMAL-DIGIT? C))))))))
  (CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
  (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 ((~G871 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G872 (~G141) (CL:COND (~G141 (CL:PROGN (CL:LABELS ((~G873 (~G143) (CL:BLOCK NIL (CL:LABELS ((~G874 (~G142) (CL:TAGBODY ~G144 (CL:COND ((== ~G142 ~G143) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G875 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G875 (ELT ~G141 ~G142))) (CL:SETQ ~G142 (NUMBER+ 1 ~G142)) (CL:GO ~G144)))) (~G874 0))))) (~G873 (CL:LENGTH ~G141)))))))) (~G872 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)) (~G871 STREAM-LOCATION (STREAM-LOCATION-TRACK? STREAM-LOCATION) (STREAM-LOCATION-ID STREAM-LOCATION) (STREAM-LOCATION-LINE STREAM-LOCATION) (STREAM-LOCATION-COLUMN STREAM-LOCATION) (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))))
  (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  (CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
  (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 ((~G876 (~G148) (CL:LABELS ((~G877 (!) (CL:TAGBODY ~G146 (CL:COND ((NOT ~G148) (CL:GO ~G147))) (CL:SETQ ! (CL:CAR ~G148)) (STREAM-PRINC ! STR) (CL:SETQ ~G148 (CL:CDR ~G148)) (CL:GO ~G146) ~G147 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G877 NIL)))) (~G876 X)))) ((CL:LABELS ((~G878 (~G145) (CL:COND (~G145 ~G145) (T (CHARACTER? X))))) (~G878 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (FUNCALL (STREAM-FUN-OUT STR) X STR))))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
  (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
  (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G257 (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 ~G257)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G879 (~G258) (CL:COND (~G258 ~G258) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G879 (CL:COND ((CL:CDR X) (CL:LABELS ((~G880 (~G259) (CL:COND (~G259 ~G259) (T (EQL #\. (CL:CAR X)))))) (~G880 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G881 (~G260) (CL:COND (~G260 ~G260) (T (EQL #\. _))))) (~G881 (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 ((~G882 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (VALUES (CL:LABELS ((~G883 (~G256) (CL:COND (~G256 ~G256) (T *KEYWORD-PACKAGE*)))) (~G883 !)) (CL:COND ((READ-CHAR STR) (READ-SYMBOL STR))))) (T (VALUES "TRE" !))))) (~G882 (READ-SYMBOL STR))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS 'CL:SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X)) "TRE") NIL)) NIL)))) (T (CL:COND ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G884 (LOC) (CL:LABELS ((~G885 (LINE) (CL:LABELS ((~G886 (COLUMN) (CL:LABELS ((~G887 (FILE) (CL:LABELS ((ERR (_) (CL:BLOCK NIL (ERROR "~A in form starting at line ~A, column ~A in file ~A." _ LINE COLUMN FILE))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G888 (~G269) (CL:COND ((EQUAL ~G269 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQUAL ~G269 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQUAL ~G269 :CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G888 TOKEN)) (CL:LABELS ((~G889 (!) (CL:COND (! (CL:LABELS ((~G890 (~G271) (CL:LABELS ((~G891 (~G272) (CL:LABELS ((~G892 (TOKEN) (CL:LABELS ((~G893 (~G273) (CL:LABELS ((~G894 (PKG) (CL:LABELS ((~G895 (~G274) (CL:LABELS ((~G896 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G897 (X) (CL:LABELS ((~G898 (~G276) (CL:LABELS ((~G899 (~G277) (CL:LABELS ((~G900 (TOKEN) (CL:LABELS ((~G901 (~G278) (CL:LABELS ((~G902 (PKG) (CL:LABELS ((~G903 (~G279) (CL:LABELS ((~G904 (SYM) (CL:LABELS ((~G905 (~G270) (CL:COND (~G270 ~G270) (T (ERR "Only one value allowed after dotted cons."))))) (~G905 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G904 (CL:CAR ~G279))))) (~G903 (CL:CDR ~G278))))) (~G902 (CL:CAR ~G278))))) (~G901 (CL:CDR ~G277))))) (~G900 (CL:CAR ~G277))))) (~G899 (CL:CDR ~G276))))) (~G898 (READ-TOKEN STR))))) (~G897 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G896 (CL:CAR ~G274))))) (~G895 (CL:CDR ~G273))))) (~G894 (CL:CAR ~G273))))) (~G893 (CL:CDR ~G272))))) (~G892 (CL:CAR ~G272))))) (~G891 (CL:CDR ~G271))))) (~G890 !))) (T (ERR "Closing bracket missing."))))) (~G889 (READ-TOKEN STR))))))))) (CL:LABELS ((~G906 (~G281) (CL:LABELS ((~G907 (~G282) (CL:LABELS ((~G908 (TOKEN) (CL:LABELS ((~G909 (~G283) (CL:LABELS ((~G910 (PKG) (CL:LABELS ((~G911 (~G284) (CL:LABELS ((~G912 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G912 (CL:CAR ~G284))))) (~G911 (CL:CDR ~G283))))) (~G910 (CL:CAR ~G283))))) (~G909 (CL:CDR ~G282))))) (~G908 (CL:CAR ~G282))))) (~G907 (CL:CDR ~G281))))) (~G906 (READ-TOKEN STR)))))) (~G887 (STREAM-LOCATION-ID LOC))))) (~G886 (STREAM-LOCATION-COLUMN LOC))))) (~G885 (STREAM-LOCATION-LINE LOC))))) (~G884 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G913 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G914 (~G242) (CL:COND (~G242 ~G242) (T (EQ X :CURLY-BRACKET-CLOSE))))) (~G914 (EQ X :SQUARE-BRACKET-CLOSE))))))) (~G913 (EQ X :BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G915 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((CONS? PKG) (LIST-STRING PKG)) (T PKG))))))) (~G915 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G916 (!) (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)))) (~G916 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G917 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G917 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G918 (~G227) (CL:COND (~G227 ~G227) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G918 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G919 (~G228) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G228)) (~G919 (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 ((~G920 (~G229) (CL:COND (~G229 ~G229) (T 0)))) (~G920 (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 ((~G921 (~G164) (CL:LABELS ((~G922 (S) (CL:LABELS ((~G923 (~G165) (CL:COND (~G164 ~G165) (T (GET-STREAM-STRING S))))) (~G923 (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))))) (~G922 (DEFAULT-STREAM ~G164))))) (~G921 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 ((~G924 (~G151) (CL:COND (~G151 (CL:PROGN (CL:LABELS ((~G925 (~G153) (CL:BLOCK NIL (CL:LABELS ((~G926 (~G152) (CL:TAGBODY ~G154 (CL:COND ((== ~G152 ~G153) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G927 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G927 (ELT ~G151 ~G152))) (CL:SETQ ~G152 (NUMBER+ 1 ~G152)) (CL:GO ~G154)))) (~G926 0))))) (~G925 (CL:LENGTH ~G151)))))))) (~G924 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:LABELS ((~G928 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G928 (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 ((~G929 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G929 (READ-CHAR STR))))))
  (CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G930 (!) (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) !)) (~G930 NIL)))))
  (CL:DEFUN DOT-EXPAND-MAKE-EXPR (WHICH NUM X) (CL:BLOCK DOT-EXPAND-MAKE-EXPR (CL:BLOCK NIL (CL:COND ((< 0 NUM) (CL:CONS WHICH (CL:CONS (DOT-EXPAND-MAKE-EXPR WHICH (-- NUM) X) NIL))) (T X)))))
  (CL:DEFUN DOT-EXPAND-TAIL-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-TAIL-LENGTH (CL:BLOCK NIL (CL:COND ((EQL #\. (CL:CAR (CL:LAST X))) (DOT-EXPAND-TAIL-LENGTH (BUTLAST X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN DOT-EXPAND-HEAD-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-HEAD-LENGTH (CL:BLOCK NIL (CL:COND ((EQL #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G931 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G932 (L) (CL:LABELS ((~G933 (S) (CL:LABELS ((~G934 (~G48) (CL:BLOCK NIL (CL:LABELS ((~G935 (X) (CL:TAGBODY ~G49 (CL:COND ((== X ~G48) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G49)))) (~G935 0))))) (~G934 L)))) (~G933 (FUNCALL MAKER L))))) (~G932 (- END START)))))))) (~G931 (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 ((~G936 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G937 (L) (CL:LABELS ((~G938 (S) (CL:LABELS ((~G939 (~G44) (CL:BLOCK NIL (CL:LABELS ((~G940 (X) (CL:TAGBODY ~G45 (CL:COND ((== X ~G44) (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 ~G45)))) (~G940 0))))) (~G939 L)))) (~G938 (CL:MAKE-STRING 0))))) (~G937 (- END START)))))))) (~G936 (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 ((~G941 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G941 START)))) (CL:LABELS ((~G942 (Q) (CL:LABELS ((~G943 (LEN) (CL:LABELS ((~G944 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G47 (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 ~G47)))))) (~G944 (CL:NTHCDR START SEQ))))) (~G943 (- END START))))) (~G942 (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)))))))
  