anchor.diff:  (CL:DEFVAR *QUASIQUOTE-EXPAND*)
   (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST #'CL:EQ))
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:GETHASH X *BUILTIN-ATOMS*)) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) #'BUILTIN?))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1510 (~G1464) (CL:COND (~G1464 ~G1464) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1510 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) #'BUILTIN?))
   (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) #'MAKE-ARRAY))
   (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) #'=-AREF))
   (CL:DEFVAR *ENVIRONMENT-PATH*)
   (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
   (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&OPTIONAL (TARGET NIL)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGET) *ENVIRONMENT-FILENAMES*)) (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) #'ENV-LOAD))
  -(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1509 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1509 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1510 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1510 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1511 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1511 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1512 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1512 (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 #'MAKE-LAMBDAS X))))
   (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
   (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (TRE2CL X))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) #'EVAL))
  -(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1511 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1512 (~G1464) (CL:BLOCK NIL (CL:LABELS ((~G1513 (!) (CL:TAGBODY ~G1465 (CL:COND ((INTEGER== ! ~G1464) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1465)))) (~G1513 0))))) (~G1512 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1511 (CL:LABELS ((~G1514 (~G1463) (CL:COND (~G1463 ~G1463) (T CL:*STANDARD-OUTPUT*)))) (~G1514 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1513 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1514 (~G1466) (CL:COND ((INTEGER< ~G1466 0) (ERROR "Negative number of iterations: ~A." ~G1466))) (CL:BLOCK NIL (CL:LABELS ((~G1515 (!) (CL:TAGBODY ~G1467 (CL:COND ((INTEGER== ! ~G1466) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1467)))) (~G1515 0))))) (~G1514 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1513 (CL:LABELS ((~G1516 (~G1465) (CL:COND (~G1465 ~G1465) (T CL:*STANDARD-OUTPUT*)))) (~G1516 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
   (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) #'%FORCE-OUTPUT))
   (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST #'CL:EQUAL) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) #'%FOPEN))
   (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) #'%FCLOSE))
  -(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1515 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1515 (CL:READ-BYTE (CL:LABELS ((~G1516 (~G1466) (CL:COND (~G1466 ~G1466) (T CL:*STANDARD-INPUT*)))) (~G1516 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1517 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1517 (CL:READ-BYTE (CL:LABELS ((~G1518 (~G1468) (CL:COND (~G1468 ~G1468) (T CL:*STANDARD-INPUT*)))) (~G1518 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
   (CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:ENSURE-DIRECTORIES-EXIST PATHNAME)) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) #'UNIX-SH-MKDIR))
   (CL:DEFVAR *FUNCTIONS*)
   (CL:PROGN (CL:DEFUN FUNCTION-NATIVE (X) X) (CL:SETF (CL:GETHASH 'FUNCTION-NATIVE *BUILTIN-ATOMS*) #'FUNCTION-NATIVE))
  -(CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:LABELS ((~G1517 (~G1467) (CL:COND (~G1467 ~G1467) (T (CL:ERROR "Not a function."))))) (~G1517 (CL:FUNCTIONP X))) (CL:GETHASH X *FUNCTIONS*)) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) #'FUNCTION-SOURCE))
  -(CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (CL:SETF (CL:GETHASH X *FUNCTIONS*) V)) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) #'=-FUNCTION-SOURCE))
  +(CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST #'CL:EQ))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) #'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*) #'=-FUNCTION-SOURCE))
   (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) #'FUNCTION-BYTECODE))
  -(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST #'EQL)) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST #'EQ) #'CL:EQ) ((CL:LABELS ((~G1518 (~G1468) (CL:COND (~G1468 ~G1468) (T (CL:EQ TEST #'==))))) (~G1518 (CL:EQ TEST #'EQL))) #'CL:EQL) ((CL:EQ TEST #'STRING==) #'CL:EQUAL) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) #'MAKE-HASH-TABLE))
  +(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST #'EQL)) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST #'EQ) #'CL:EQ) ((CL:LABELS ((~G1519 (~G1469) (CL:COND (~G1469 ~G1469) (T (CL:EQ TEST #'==))))) (~G1519 (CL:EQ TEST #'EQL))) #'CL:EQL) ((CL:EQ TEST #'STRING==) #'CL:EQUAL) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) #'MAKE-HASH-TABLE))
   (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) #'HASH-TABLE?))
   (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) #'HREF))
   (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) #'=-HREF))
   (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) #'HREMOVE))
  -(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1519 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1519 (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*) #'COPY-HASH-TABLE))
  -(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1520 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1520 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'HASHKEYS))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1520 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1520 (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*) #'COPY-HASH-TABLE))
  +(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1521 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1521 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'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*) #'SYS-IMAGE-CREATE))
  -(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1521 (~G1470) (CL:COND (~G1470 ~G1470) (T NIL)))) (~G1521 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) #'%START-CORE))
  +(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1522 (~G1471) (CL:COND (~G1471 ~G1471) (T NIL)))) (~G1522 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) #'%START-CORE))
   (CL:DEFVAR *DEFAULT-LISTPROP*)
   (CL:PROGN (CL:DEFUN CPR (X) X NIL) (CL:SETF (CL:GETHASH 'CPR *BUILTIN-ATOMS*) #'CPR))
   (CL:PROGN (CL:DEFUN RPLACP (V X) X V) (CL:SETF (CL:GETHASH 'RPLACP *BUILTIN-ATOMS*) #'RPLACP))
  
positive.code: (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
  (CL:DEFVAR *MACROCALL*)
  (CL:DEFVAR *MACRO?*)
  (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:SETQ *UNIVERSE* NIL)
  (CL:SETQ *VARIABLES* NIL)
  
negative.code: (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (LIST-STRING (READ-STRING-0 STR)))))
  (CL:DEFUN READ-STRING-0 (STR) (CL:BLOCK READ-STRING-0 (CL:BLOCK NIL (CL:LABELS ((~G1762 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1762 (READ-CHAR STR))))))
  (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST TOKEN (READ-EXPR STR)))))
  (CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1763 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G1764 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G1765 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G1766 (~G239) (CL:COND (~G239 ~G239) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1766 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1765 (EQ X 'QUASIQUOTE))))))) (~G1764 (EQ X 'BACKQUOTE))))))) (~G1763 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1767 (~G296) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1768 (~G302) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G296)) ~G302)) (~G1768 (CL:PROGN (CL:LABELS ((~G1769 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1770 (~G297) (CL:LABELS ((~G1771 (~G298) (CL:COND ((NOT (EQ (CL:CAR ~G297) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G297)))) (CL:LABELS ((~G1772 (TOKEN) (CL:LABELS ((~G1773 (~G299) (CL:LABELS ((~G1774 (PKG) (CL:LABELS ((~G1775 (~G300) (CL:LABELS ((~G1776 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1776 (CL:CAR ~G300))))) (~G1775 (CL:LABELS ((~G1777 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1777 (CL:CDR ~G299))))))) (~G1774 (CL:CAR ~G299))))) (~G1773 (CL:LABELS ((~G1778 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1778 (CL:CDR ~G298))))))) (~G1772 (CL:CAR ~G298))))) (~G1771 (CL:CDR ~G297))))) (~G1770 (READ-TOKEN STR))))) (T !)))) (~G1769 (READ-CONS STR)))))))) (~G1767 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1779 (LOC) (CL:LABELS ((~G1780 (LINE) (CL:LABELS ((~G1781 (COLUMN) (CL:LABELS ((~G1782 (FILE) (CL:LABELS ((ERR (_) (CL:BLOCK NIL (ERROR "~A in form starting at line ~A, column ~A in file ~A." _ LINE COLUMN FILE))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G1783 (~G270) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1784 (~G273) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G270)) ~G273)) (~G1784 (CL:PROGN (CL:LABELS ((~G1785 (~G269) (CL:COND ((EQ ~G269 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G269 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~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))))))) (~G1785 TOKEN))))))) (~G1783 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1786 (~G272) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1787 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G272)) ~G279)) (~G1787 (CL:PROGN (CL:LABELS ((~G1788 (!) (CL:COND (! (CL:LABELS ((~G1789 (~G274) (CL:LABELS ((~G1790 (~G275) (CL:COND ((NOT (EQ (CL:CAR ~G274) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G274)))) (CL:LABELS ((~G1791 (TOKEN) (CL:LABELS ((~G1792 (~G276) (CL:LABELS ((~G1793 (PKG) (CL:LABELS ((~G1794 (~G277) (CL:LABELS ((~G1795 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1796 (X) (CL:LABELS ((~G1797 (~G282) (CL:LABELS ((~G1798 (~G283) (CL:COND ((NOT (EQ (CL:CAR ~G282) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G282)))) (CL:LABELS ((~G1799 (TOKEN) (CL:LABELS ((~G1800 (~G284) (CL:LABELS ((~G1801 (PKG) (CL:LABELS ((~G1802 (~G285) (CL:LABELS ((~G1803 (SYM) (CL:LABELS ((~G1804 (~G271) (CL:COND (~G271 ~G271) (T (ERR "Only one value allowed after dotted cons."))))) (~G1804 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1803 (CL:CAR ~G285))))) (~G1802 (CL:LABELS ((~G1805 (~G288) (CL:COND (~G288 ~G288) (T (%ERROR "Not enough VALUES."))))) (~G1805 (CL:CDR ~G284))))))) (~G1801 (CL:CAR ~G284))))) (~G1800 (CL:LABELS ((~G1806 (~G287) (CL:COND (~G287 ~G287) (T (%ERROR "Not enough VALUES."))))) (~G1806 (CL:CDR ~G283))))))) (~G1799 (CL:CAR ~G283))))) (~G1798 (CL:CDR ~G282))))) (~G1797 (READ-TOKEN STR))))) (~G1796 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1795 (CL:CAR ~G277))))) (~G1794 (CL:LABELS ((~G1807 (~G281) (CL:COND (~G281 ~G281) (T (%ERROR "Not enough VALUES."))))) (~G1807 (CL:CDR ~G276))))))) (~G1793 (CL:CAR ~G276))))) (~G1792 (CL:LABELS ((~G1808 (~G280) (CL:COND (~G280 ~G280) (T (%ERROR "Not enough VALUES."))))) (~G1808 (CL:CDR ~G275))))))) (~G1791 (CL:CAR ~G275))))) (~G1790 (CL:CDR ~G274))))) (~G1789 !))) (T (ERR "Closing bracket missing."))))) (~G1788 (READ-TOKEN STR)))))))) (~G1786 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1809 (~G289) (CL:LABELS ((~G1810 (~G290) (CL:COND ((NOT (EQ (CL:CAR ~G289) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G289)))) (CL:LABELS ((~G1811 (TOKEN) (CL:LABELS ((~G1812 (~G291) (CL:LABELS ((~G1813 (PKG) (CL:LABELS ((~G1814 (~G292) (CL:LABELS ((~G1815 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1815 (CL:CAR ~G292))))) (~G1814 (CL:LABELS ((~G1816 (~G295) (CL:COND (~G295 ~G295) (T (%ERROR "Not enough VALUES."))))) (~G1816 (CL:CDR ~G291))))))) (~G1813 (CL:CAR ~G291))))) (~G1812 (CL:LABELS ((~G1817 (~G294) (CL:COND (~G294 ~G294) (T (%ERROR "Not enough VALUES."))))) (~G1817 (CL:CDR ~G290))))))) (~G1811 (CL:CAR ~G290))))) (~G1810 (CL:CDR ~G289))))) (~G1809 (READ-TOKEN STR)))))) (~G1782 (STREAM-LOCATION-ID LOC))))) (~G1781 (STREAM-LOCATION-COLUMN LOC))))) (~G1780 (STREAM-LOCATION-LINE LOC))))) (~G1779 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1818 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1818 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1819 (~G223) (CL:COND (~G223 ~G223) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1819 (HREF *MEMORIZED-NUMBERS* X))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1820 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1821 (~G262) (CL:LABELS ((~G1822 (~G263) (CL:COND ((NOT (EQ (CL:CAR ~G262) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G262)))) (CL:LABELS ((~G1823 (PKG) (CL:LABELS ((~G1824 (~G264) (CL:LABELS ((~G1825 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (== #\. (CL:CAR SYM)))))) 'DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) 'NUMBER) (T 'SYMBOL))) (T (CL:LABELS ((~G1826 (~G261) (CL:COND ((CHARACTER== ~G261 #\() 'BRACKET-OPEN) ((CHARACTER== ~G261 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G261 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G261 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G261 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G261 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G261 #\') 'CL:QUOTE) ((CHARACTER== ~G261 #\`) 'BACKQUOTE) ((CHARACTER== ~G261 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G261 #\") 'DBLQUOTE) ((CHARACTER== ~G261 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G261 #\#) (CL:LABELS ((~G1827 (~G260) (CL:COND ((CHARACTER== ~G260 #\\) 'CHAR) ((CHARACTER== ~G260 #\x) 'HEXNUM) ((CHARACTER== ~G260 #\') 'CL:FUNCTION) ((CHARACTER== ~G260 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1827 (READ-CHAR STR)))) ((CHARACTER== ~G261 -1) 'EOF)))) (~G1826 (READ-CHAR STR))))))) PKG SYM))) (~G1825 (CL:CAR ~G264))))) (~G1824 (CL:LABELS ((~G1828 (~G266) (CL:COND (~G266 ~G266) (T (%ERROR "Not enough VALUES."))))) (~G1828 (CL:CDR ~G263))))))) (~G1823 (CL:CAR ~G263))))) (~G1822 (CL:CDR ~G262))))) (~G1821 !))))))) (~G1820 (GET-SYMBOL-AND-PACKAGE STR))))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G256 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G256)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1829 (~G258) (CL:COND (~G258 ~G258) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1829 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1830 (~G257) (CL:COND (~G257 ~G257) (T (== #\. (CL:CAR X)))))) (~G1830 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1831 (~G259) (CL:COND (~G259 ~G259) (T (== #\. _))))) (~G1831 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1832 (~G108) (CL:LABELS ((~G1833 (SEQ) (CL:TAGBODY ~G106 (CL:COND ((NOT ~G108) (CL:GO ~G107))) (CL:SETQ SEQ (CL:CAR ~G108)) (CL:LABELS ((~G1834 (~G105) (CL:COND ((INTEGER< ~G105 0) (ERROR "Negative number of iterations: ~A." ~G105))) (CL:BLOCK NIL (CL:LABELS ((~G1835 (!) (CL:TAGBODY ~G109 (CL:COND ((INTEGER== ! ~G105) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1836 (~G104) (CL:COND (~G104 ~G104) (T (CL:RETURN-FROM EVERY NIL))))) (~G1836 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G109)))) (~G1835 0))))) (~G1834 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G108 (CL:CDR ~G108)) (CL:GO ~G106) ~G107 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1833 NIL)))) (~G1832 SEQS))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1837 (SYM) (CL:LABELS ((~G1838 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1839 (~G255) (CL:COND (~G255 ~G255) (T T)))) (~G1839 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1838 (PEEK-CHAR STR))))) (~G1837 (GET-SYMBOL STR))))))
  (CL:DEFUN GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1840 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1840 (PEEK-CHAR STR))))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1841 (C) (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR) (GET-SYMBOL-0 STR))) (T (CL:COND ((SYMBOL-CHAR? C) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (GET-SYMBOL-0 STR)))))))) (~G1841 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1842 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1842 (READ-CHAR STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1843 (C) (CL:COND (C (CL:PROGN (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? C) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR))))))))) (~G1843 (PEEK-CHAR STR))))))
  (CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((< X 33) (>= X 0))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1844 (~G225) (CL:COND (~G225 ~G225) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1844 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1845 (~G325) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1846 (~G326) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G325)) ~G326)) (~G1846 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY #'FORMAT NIL MSG ARGS))))))) (~G1845 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G899 (X) (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1847 (~G897) (CL:COND ((CL:ATOM ~G897) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G897) (QQ _)) ((QUASIQUOTE-SPLICE? ~G897) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1847 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1848 (~G898) (CL:COND ((QUOTE? ~G898) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G898) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1848 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING #'DISP))))) (CL:COND ((NOT (DUMP-PASS? 'QUOTE-EXPAND)) (CL:PROGN (CL:RETURN-FROM NIL (~G899 X))))) (FRESH-LINE) (FORMAT T "; **** QUOTE-EXPAND~%") (CL:LABELS ((~G1849 (~G900) (FRESH-LINE) (FORMAT T "; **** end of QUOTE-EXPAND~%") ~G900)) (~G1849 (CL:LABELS ((~G1850 (~G901) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* X)) (CL:LABELS ((~G1851 (~G903) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* ~G901)) ~G903)) (~G1851 (CL:PROGN (CL:LABELS ((~G1852 (~G902) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* T)) (CL:LABELS ((~G1853 (~G904) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* ~G902)) ~G904)) (~G1853 (CL:PROGN (LATE-PRINT (~G899 X))))))) (~G1852 *ALWAYS-PRINT-PACKAGE-NAMES?*))))))) (~G1850 *CURRENT-PASS-INPUT*))))))))
  (CL:DEFUN DUMP-PASS? (NAME) (CL:BLOCK DUMP-PASS? (CL:BLOCK NIL (CL:COND (*TRANSPILER* (CL:LABELS ((~G1854 (!) (CL:COND (! (CL:LABELS ((~G1855 (~G432) (CL:COND (~G432 ~G432) (T (MEMBER NAME (ENSURE-LIST !)))))) (~G1855 (EQ T !))))))) (~G1854 (DUMP-PASSES?))))))))
  (CL:DEFUN ENSURE-LIST (X) (CL:BLOCK ENSURE-LIST (CL:BLOCK NIL (CL:COND ((CONS? X) X) (T (CL:LIST X))))))
  (CL:DEFUN MEMBER (ELM LST CL:&KEY (TEST #'EQL)) (CL:BLOCK MEMBER (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1856 (I) (CL:TAGBODY ~G23 (CL:COND ((NOT I) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:COND ((FUNCALL TEST ELM (CL:CAR I)) (CL:RETURN-FROM MEMBER I))) (CL:SETQ I (CL:CDR I)) (CL:GO ~G23)))) (~G1856 LST))))))
  (CL:DEFUN DUMP-PASSES? NIL (CL:BLOCK DUMP-PASSES? (CL:BLOCK NIL (CL:AREF *TRANSPILER* 61))))
  (CL:DEFUN TREE-WALK (I CL:&KEY (ASCENDING NIL) (DONT-ASCEND-IF NIL) (DONT-ASCEND-AFTER-IF NIL)) (CL:BLOCK TREE-WALK (CL:BLOCK NIL (CL:COND ((CL:ATOM I) (FUNCALL ASCENDING I)) (T (CL:PROGN (CL:LABELS ((~G1857 (Y) (CL:LABELS ((~G1858 (A) (CL:PROGN (CL:LABELS ((~G1859 (~G364) (CL:LABELS ((~G1860 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1860 (CL:COND ((CONS? ~G364) (CPR ~G364))))))) (~G1859 I)) (CL:LABELS ((~G1861 (~G363) (RPLACP (CL:CONS A (TREE-WALK (CL:CDR I) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF)) ~G363))) (~G1861 *DEFAULT-LISTPROP*))))) (~G1858 (CL:LABELS ((~G1862 (~G362) (CL:COND (~G362 ~G362) (T (CL:COND ((CL:COND (DONT-ASCEND-AFTER-IF (FUNCALL DONT-ASCEND-AFTER-IF Y))) (FUNCALL ASCENDING Y)) (T (TREE-WALK (CL:COND (ASCENDING (FUNCALL ASCENDING Y)) (T Y)) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF))))))) (~G1862 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1857 (CL:CAR I)))))))))
  (CL:DEFUN BACKQUOTE? (X) (CL:BLOCK BACKQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'BACKQUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN QUOTE? (X) (CL:BLOCK QUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:QUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN QUASIQUOTE-SPLICE? (X) (CL:BLOCK QUASIQUOTE-SPLICE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE-SPLICE (CL:CAR X)) X)))))))
  (CL:DEFUN QUASIQUOTE? (X) (CL:BLOCK QUASIQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE (CL:CAR X)) X)))))))
  (CL:DEFUN ANY-QUASIQUOTE? (X) (CL:COND ((CONS? X) (CL:COND ((EQ (CL:CAR X) 'QUASIQUOTE) T) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) T)))))
  (CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1863 (~G423) (CL:COND (~G423 ~G423) (T (CL:LABELS ((~G1864 (~G424) (CL:COND (~G424 ~G424) (T (CL:LABELS ((~G1865 (~G425) (CL:COND (~G425 ~G425) (T (CL:LABELS ((~G1866 (~G426) (CL:COND (~G426 ~G426) (T (CL:LABELS ((~G1867 (~G427) (CL:COND (~G427 ~G427) (T (HASH-TABLE? X))))) (~G1867 (ARRAY? X))))))) (~G1866 (STRING? X))))))) (~G1865 (NUMBER? X))))))) (~G1864 (EQ T X))))))) (~G1863 (NOT X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1868 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1868 (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 ((~G1869 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1869 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1870 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) #'APPEND) ((STRING? A) #'STRING-CONCAT) (T #'NUMBER+)) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY #'+ (CL:CDR X)))))))) (~G1870 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFVAR *GENSYM-PREFIX*)
  