anchor.diff:  (CL:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY #'%> X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) #'>))
   (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 ((~G1516 (!) (CL:LABELS ((~G1517 (L) (CL:LABELS ((~G1518 (~G1463) (CL:BLOCK NIL (CL:LABELS ((~G1519 (I) (CL:TAGBODY ~G1464 (CL:COND ((INTEGER== I ~G1463) (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 (INTEGER+ 1 I)) (CL:GO ~G1464)))) (~G1519 0))))) (~G1518 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1517 NIL)))) (~G1516 (NUMBER X))))
  +(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G1518 (!) (CL:LABELS ((~G1519 (L) (CL:LABELS ((~G1520 (~G1464) (CL:BLOCK NIL (CL:LABELS ((~G1521 (I) (CL:TAGBODY ~G1465 (CL:COND ((INTEGER== I ~G1464) (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 (INTEGER+ 1 I)) (CL:GO ~G1465)))) (~G1521 0))))) (~G1520 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1519 NIL)))) (~G1518 (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*) #'BIT-AND))
  -(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1520 (!) (CL:LABELS ((~G1521 (~G1465) (CL:BLOCK NIL (CL:LABELS ((~G1522 (N) (CL:TAGBODY ~G1466 (CL:COND ((INTEGER== N ~G1465) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1466)))) (~G1522 0))))) (~G1521 (INTEGER BITS))))) (~G1520 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  -(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1523 (!) (CL:LABELS ((~G1524 (~G1467) (CL:BLOCK NIL (CL:LABELS ((~G1525 (N) (CL:TAGBODY ~G1468 (CL:COND ((INTEGER== N ~G1467) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1468)))) (~G1525 0))))) (~G1524 (INTEGER BITS))))) (~G1523 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) #'<<))
  +(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1522 (!) (CL:LABELS ((~G1523 (~G1466) (CL:BLOCK NIL (CL:LABELS ((~G1524 (N) (CL:TAGBODY ~G1467 (CL:COND ((INTEGER== N ~G1466) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1467)))) (~G1524 0))))) (~G1523 (INTEGER BITS))))) (~G1522 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  +(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1525 (!) (CL:LABELS ((~G1526 (~G1468) (CL:BLOCK NIL (CL:LABELS ((~G1527 (N) (CL:TAGBODY ~G1469 (CL:COND ((INTEGER== N ~G1468) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1469)))) (~G1527 0))))) (~G1526 (INTEGER BITS))))) (~G1525 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) #'<<))
   (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY #'CL:NOT X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) #'NOT))
  -(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1526 (~G1472) (CL:LABELS ((~G1527 (I) (CL:TAGBODY ~G1470 (CL:COND ((NOT ~G1472) (CL:GO ~G1471))) (CL:SETQ I (CL:CAR ~G1472)) (CL:LABELS ((~G1528 (~G1469) (CL:COND (~G1469 ~G1469) (T (CL:RETURN-FROM NIL NIL))))) (~G1528 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1472 (CL:CDR ~G1472)) (CL:GO ~G1470) ~G1471 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1527 NIL)))) (~G1526 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
  +(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1528 (~G1473) (CL:LABELS ((~G1529 (I) (CL:TAGBODY ~G1471 (CL:COND ((NOT ~G1473) (CL:GO ~G1472))) (CL:SETQ I (CL:CAR ~G1473)) (CL:LABELS ((~G1530 (~G1470) (CL:COND (~G1470 ~G1470) (T (CL:RETURN-FROM NIL NIL))))) (~G1530 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1473 (CL:CDR ~G1473)) (CL:GO ~G1471) ~G1472 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1529 NIL)))) (~G1528 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
   (CL:DEFUN TRE-EQL (A B) (CL:COND ((CL:COND ((NUMBER? A) (NUMBER? B))) (CL:COND ((CL:EQ (CL:CHARACTERP A) (CL:CHARACTERP B)) (== A B)))) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((TRE-EQL (CL:CAR A) (CL:CAR B)) (TRE-EQL (CL:CDR A) (CL:CDR B))))) (T (CL:EQ A B))))
   (CL:PROGN (CL:DEFUN EQ (CL:&REST X) (VARIABLE-COMPARE #'CL:EQ X)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) #'EQ))
   (CL:PROGN (CL:DEFUN EQL (CL:&REST X) (VARIABLE-COMPARE #'TRE-EQL X)) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) #'EQL))
  
positive.code: (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) 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 (%MACROEXPAND-CALL (%MACROEXPAND-REST X)))))
  (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN %MACROEXPAND-CALL (X) (CL:COND ((CL:APPLY *MACRO?* (CL:LIST X)) (%MACROEXPAND-XLAT X)) (T X)))
  (CL:DEFUN %MACROEXPAND-XLAT (X) (CL:COND (*MACROEXPAND-PRINT?* (CL:PROGN (CL:PRINT '*MACROEXPAND-PRINT?*) (CL:PRINT X)))) (CL:SETQ *CURRENT-MACRO* (CL:CAR X)) (CL:LABELS ((~G1660 (X) (CL:COND (*MACROEXPAND-PRINT?* (CL:PRINT X))) (CL:SETQ *CURRENT-MACRO* NIL) X)) (~G1660 (CL:APPLY *MACROCALL* (CL:LIST X)))))
  (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((CL:COND ((CONS? _) (EQ (CL:CAR _) '%REST))) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS))))))
  (CL:DEFUN CDRLIST (~G127) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER #'CL:CDR ~G127))))
  (CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST #'EQL)) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1661 (~G130) (CL:LABELS ((~G1662 (I) (CL:TAGBODY ~G128 (CL:COND ((NOT ~G130) (CL:GO ~G129))) (CL:SETQ I (CL:CAR ~G130)) (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 ~G130 (CL:CDR ~G130)) (CL:GO ~G128) ~G129 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1662 NIL)))) (~G1661 LST))))))))
  (CL:DEFUN TRE-SYMBOL (X) (CL:BLOCK TRE-SYMBOL (CL:BLOCK NIL (CL:INTERN (SYMBOL-NAME X) "TRE"))))
  (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 ((~G1663 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1663 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION :TRACK? NIL))) (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 %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1664 (~G164) (CL:COND ((EQUAL ~G164 'INPUT) "r") ((EQUAL ~G164 'OUTPUT) "w") ((EQUAL ~G164 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1664 DIRECTION)))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  (CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:LABELS ((LABEL? (_) (CL:BLOCK NIL (NOT (CL:LABELS ((~G1665 (~G122) (CL:COND (~G122 ~G122) (T (CL:LABELS ((~G1666 (~G123) (CL:COND (~G123 ~G123) (T (STRING? _))))) (~G1666 (NUMBER? _))))))) (~G1665 (CONS? _))))))) (CL:COND (X (CL:PROGN (CL:COND ((LABEL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1667 (~G125) (CL:LABELS ((~G1668 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1668 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1667 X)) (CL:LABELS ((~G1669 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1669 *DEFAULT-LISTPROP*)))) (T X)))))))))
  (CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1670 (SL) (CL:LABELS ((~G1671 (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))))))) (~G1671 (DOT-POSITION SL))))) (~G1670 (STRING-LIST (SYMBOL-NAME 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 ((~G1672 (~G62) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G62)))) (~G1672 START)))) (CL:LABELS ((~G1673 (~G63) (CL:COND ((CONS? ~G63) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G63) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G63) (%SUBSEQ-SEQUENCE #'MAKE-ARRAY SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1673 SEQ))))))))
  (CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1674 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1675 (L) (CL:LABELS ((~G1676 (S) (CL:LABELS ((~G1677 (~G60) (CL:BLOCK NIL (CL:LABELS ((~G1678 (X) (CL:TAGBODY ~G61 (CL:COND ((INTEGER== X ~G60) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G61)))) (~G1678 0))))) (~G1677 (INTEGER L))))) (~G1676 (FUNCALL MAKER L))))) (~G1675 (- END START)))))))) (~G1674 (CL:LENGTH SEQ)))))))))
  (CL:DEFUN =-ELT (VAL SEQ IDX) (CL:BLOCK =-ELT (CL:BLOCK NIL (%SET-ELT VAL SEQ IDX))))
  (CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1679 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1680 (L) (CL:LABELS ((~G1681 (S) (CL:LABELS ((~G1682 (~G57) (CL:BLOCK NIL (CL:LABELS ((~G1683 (X) (CL:TAGBODY ~G58 (CL:COND ((INTEGER== X ~G57) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (+ S (STRING (ELT SEQ (+ START X)))))) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G58)))) (~G1683 0))))) (~G1682 (INTEGER L))))) (~G1681 (CL:MAKE-STRING 0))))) (~G1680 (- END START)))))))) (~G1679 (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 ((~G1684 (~G59) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G59)))) (~G1684 START)))) (CL:LABELS ((COPY-NUM (LST LEN) (CL:COND (LST (CL:COND ((< 0 LEN) (CL:CONS (CL:CAR LST) (COPY-NUM (CL:CDR LST) (-- LEN))))))))) (COPY-NUM (CL:NTHCDR START SEQ) (- END START)))))))))
  (CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING X)))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1685 (~G110) (CL:LABELS ((~G1686 (~G111) (CL:COND ((NOT (EQ (CL:CAR ~G110) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G110)))) (CL:LABELS ((~G1687 (NUM-CDRS) (CL:LABELS ((~G1688 (~G112) (CL:LABELS ((~G1689 (WITHOUT-START) (CL:LABELS ((~G1690 (~G115) (CL:LABELS ((~G1691 (~G116) (CL:COND ((NOT (EQ (CL:CAR ~G115) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G115)))) (CL:LABELS ((~G1692 (NUM-CARS) (CL:LABELS ((~G1693 (~G117) (CL:LABELS ((~G1694 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1694 (CL:CAR ~G117))))) (~G1693 (CL:LABELS ((~G1695 (~G119) (CL:COND (~G119 ~G119) (T (%ERROR "Not enough VALUES."))))) (~G1695 (CL:CDR ~G116))))))) (~G1692 (CL:CAR ~G116))))) (~G1691 (CL:CDR ~G115))))) (~G1690 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1689 (CL:CAR ~G112))))) (~G1688 (CL:LABELS ((~G1696 (~G114) (CL:COND (~G114 ~G114) (T (%ERROR "Not enough VALUES."))))) (~G1696 (CL:CDR ~G111))))))) (~G1687 (CL:CAR ~G111))))) (~G1686 (CL:CDR ~G110))))) (~G1685 (DOT-EXPAND-HEAD-LENGTH X))))))
  (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 ((== #\. (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 ((== #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1697 (SL) (CL:LABELS ((~G1698 (~G121) (CL:COND (~G121 ~G121) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1698 (== #\. (CL:CAR SL)))))) (~G1697 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1699 (SL) (CL:LABELS ((~G1700 (L) (CL:LABELS ((~G1701 (P) (CL:LABELS ((~G1702 (~G120) (CL:COND (~G120 ~G120) (T (NOT P))))) (~G1702 (== 1 L))))) (~G1701 (DOT-POSITION SL))))) (~G1700 (CL:LENGTH SL))))) (~G1699 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST #'==))))
  (CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST #'EQL)) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1703 (!) (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) !)) (~G1703 NIL)))))
  (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  (CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
  (CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (SKIP-SPACES STR) (CL:COND ((PEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1704 (~G304) (CL:LABELS ((~G1705 (~G305) (CL:COND ((NOT (EQ (CL:CAR ~G304) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G304)))) (CL:LABELS ((~G1706 (TOKEN) (CL:LABELS ((~G1707 (~G306) (CL:LABELS ((~G1708 (PKG) (CL:LABELS ((~G1709 (~G307) (CL:LABELS ((~G1710 (SYM) (CL:LABELS ((~G1711 (~G303) (CL:COND ((EQ ~G303 NIL) NIL) ((EQ ~G303 'EOF) NIL) ((EQ ~G303 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G303 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G303 '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))))))) (~G1711 TOKEN)))) (~G1710 (CL:CAR ~G307))))) (~G1709 (CL:LABELS ((~G1712 (~G310) (CL:COND (~G310 ~G310) (T (%ERROR "Not enough VALUES."))))) (~G1712 (CL:CDR ~G306))))))) (~G1708 (CL:CAR ~G306))))) (~G1707 (CL:LABELS ((~G1713 (~G309) (CL:COND (~G309 ~G309) (T (%ERROR "Not enough VALUES."))))) (~G1713 (CL:CDR ~G305))))))) (~G1706 (CL:CAR ~G305))))) (~G1705 (CL:CDR ~G304))))) (~G1704 (READ-TOKEN STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1714 (~G266) (CL:COND ((EQ ~G266 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G266 'CHAR) (READ-CHAR STR)) ((EQ ~G266 'NUMBER) (CL:LABELS ((~G1715 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1715 (MAKE-STRING-STREAM)))) ((EQ ~G266 'HEXNUM) (READ-HEX STR)) ((EQ ~G266 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G266 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))) (~G1714 TOKEN)))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1716 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (CL:COND (*READER-FINDS-SYMBOLS?* (CL:FIND-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) CL:*PACKAGE*) (T (CL:FIND-PACKAGE (CL:COND ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))))) (~G1716 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS 'SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X))) NIL)) NIL)))) (T (CL:COND ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))))))
  (CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST #'EQL) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (GENERIC-SPLIT OBJ SEQ :TEST TEST :INCLUDE? INCLUDE?))))
  (CL:DEFUN GENERIC-SPLIT (OBJ SEQ CL:&KEY (TEST #'EQL) (INCLUDE? NIL)) (CL:BLOCK GENERIC-SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G1717 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1717 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1718 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1718 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1719 (~G225) (CL:COND (~G225 ~G225) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1719 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1720 (~G226) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G226)) (~G1720 (REC 0)))))))
  (CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND ((> X 32) (NOT (SPECIAL-CHAR? X)))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1721 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G1722 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G1723 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G1724 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G1725 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1726 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1727 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1728 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G1729 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1730 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G1731 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1732 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1733 (~G253) (CL:COND (~G253 ~G253) (T (== X #\^))))) (~G1733 (== X #\#))))))) (~G1732 (== X #\"))))))) (~G1731 (== X #\;))))))) (~G1730 (== X #\:))))))) (~G1729 (== X #\,))))))) (~G1728 (== X #\`))))))) (~G1727 (== X #\'))))))) (~G1726 (== X #\}))))))) (~G1725 (== X #\{))))))) (~G1724 (== X #\]))))))) (~G1723 (== X #\[))))))) (~G1722 (== X #\)))))))) (~G1721 (== X #\())))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1734 (~G81) (CL:COND (~G81 ~G81) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1734 (DECIMAL-DIGIT? C))))))))
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G1735 (~G80) (CL:COND (~G80 ~G80) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1735 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN %NONDECIMAL-DIGIT? (X START BASE) (CL:BLOCK %NONDECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X START (CHARACTER+ START (CHARACTER- BASE 10))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X #\0 #\9))))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1736 (~G82) (CL:COND (~G82 ~G82) (T (CL:LABELS ((~G1737 (~G83) (CL:COND (~G83 ~G83) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1737 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1736 (DIGIT-CHAR? X))))))
  (CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((== #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1738 (~G227) (CL:COND (~G227 ~G227) (T 0)))) (~G1738 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  (CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1739 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1739 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  (CL:DEFUN READ-DECIMAL-PLACES-0 (STR V S) (CL:BLOCK READ-DECIMAL-PLACES-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-DECIMAL-PLACES-0 STR (+ V (* S (DIGIT-NUMBER (READ-CHAR STR)))) (/ S 10))) (T V)))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- X #\0))))
  (CL:DEFUN PEEK-DIGIT (STR) (CL:BLOCK PEEK-DIGIT (CL:BLOCK NIL (CL:LABELS ((~G1740 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1740 (PEEK-CHAR STR))))))
  (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G1741 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1741 (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 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 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 READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1742 (~G223) (CL:COND (~G223 ~G223) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1742 (READ-PEEKED-CHAR STR))))))
  (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 ((~G1743 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1743 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN =-STREAM-PEEKED-CHAR (VAL ARR) (CL:BLOCK =-STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 7)))))
  (CL:DEFUN STREAM-PEEKED-CHAR (ARR) (CL:BLOCK STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:AREF ARR 7))))
  (CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
  (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 ((~G1744 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1744 (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 ((~G1745 (~G235) (CL:COND (~G235 ~G235) (T (CL:LABELS ((~G1746 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G1747 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G1748 (~G238) (CL:COND (~G238 ~G238) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1748 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1747 (EQ X 'QUASIQUOTE))))))) (~G1746 (EQ X 'BACKQUOTE))))))) (~G1745 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1749 (~G294) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1750 (~G300) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G294)) ~G300)) (~G1750 (CL:PROGN (CL:LABELS ((~G1751 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1752 (~G295) (CL:LABELS ((~G1753 (~G296) (CL:COND ((NOT (EQ (CL:CAR ~G295) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G295)))) (CL:LABELS ((~G1754 (TOKEN) (CL:LABELS ((~G1755 (~G297) (CL:LABELS ((~G1756 (PKG) (CL:LABELS ((~G1757 (~G298) (CL:LABELS ((~G1758 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1758 (CL:CAR ~G298))))) (~G1757 (CL:LABELS ((~G1759 (~G302) (CL:COND (~G302 ~G302) (T (%ERROR "Not enough VALUES."))))) (~G1759 (CL:CDR ~G297))))))) (~G1756 (CL:CAR ~G297))))) (~G1755 (CL:LABELS ((~G1760 (~G301) (CL:COND (~G301 ~G301) (T (%ERROR "Not enough VALUES."))))) (~G1760 (CL:CDR ~G296))))))) (~G1754 (CL:CAR ~G296))))) (~G1753 (CL:CDR ~G295))))) (~G1752 (READ-TOKEN STR))))) (T !)))) (~G1751 (READ-CONS STR)))))))) (~G1749 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1761 (LOC) (CL:LABELS ((~G1762 (LINE) (CL:LABELS ((~G1763 (COLUMN) (CL:LABELS ((~G1764 (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 ((~G1765 (~G268) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1766 (~G271) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G268)) ~G271)) (~G1766 (CL:PROGN (CL:LABELS ((~G1767 (~G267) (CL:COND ((EQ ~G267 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G267 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G267 '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))))))) (~G1767 TOKEN))))))) (~G1765 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1768 (~G270) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1769 (~G277) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G270)) ~G277)) (~G1769 (CL:PROGN (CL:LABELS ((~G1770 (!) (CL:COND (! (CL:LABELS ((~G1771 (~G272) (CL:LABELS ((~G1772 (~G273) (CL:COND ((NOT (EQ (CL:CAR ~G272) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G272)))) (CL:LABELS ((~G1773 (TOKEN) (CL:LABELS ((~G1774 (~G274) (CL:LABELS ((~G1775 (PKG) (CL:LABELS ((~G1776 (~G275) (CL:LABELS ((~G1777 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1778 (X) (CL:LABELS ((~G1779 (~G280) (CL:LABELS ((~G1780 (~G281) (CL:COND ((NOT (EQ (CL:CAR ~G280) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G280)))) (CL:LABELS ((~G1781 (TOKEN) (CL:LABELS ((~G1782 (~G282) (CL:LABELS ((~G1783 (PKG) (CL:LABELS ((~G1784 (~G283) (CL:LABELS ((~G1785 (SYM) (CL:LABELS ((~G1786 (~G269) (CL:COND (~G269 ~G269) (T (ERR "Only one value allowed after dotted cons"))))) (~G1786 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1785 (CL:CAR ~G283))))) (~G1784 (CL:LABELS ((~G1787 (~G286) (CL:COND (~G286 ~G286) (T (%ERROR "Not enough VALUES."))))) (~G1787 (CL:CDR ~G282))))))) (~G1783 (CL:CAR ~G282))))) (~G1782 (CL:LABELS ((~G1788 (~G285) (CL:COND (~G285 ~G285) (T (%ERROR "Not enough VALUES."))))) (~G1788 (CL:CDR ~G281))))))) (~G1781 (CL:CAR ~G281))))) (~G1780 (CL:CDR ~G280))))) (~G1779 (READ-TOKEN STR))))) (~G1778 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1777 (CL:CAR ~G275))))) (~G1776 (CL:LABELS ((~G1789 (~G279) (CL:COND (~G279 ~G279) (T (%ERROR "Not enough VALUES."))))) (~G1789 (CL:CDR ~G274))))))) (~G1775 (CL:CAR ~G274))))) (~G1774 (CL:LABELS ((~G1790 (~G278) (CL:COND (~G278 ~G278) (T (%ERROR "Not enough VALUES."))))) (~G1790 (CL:CDR ~G273))))))) (~G1773 (CL:CAR ~G273))))) (~G1772 (CL:CDR ~G272))))) (~G1771 !))) (T (ERR "Missing closing bracket"))))) (~G1770 (READ-TOKEN STR)))))))) (~G1768 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1791 (~G287) (CL:LABELS ((~G1792 (~G288) (CL:COND ((NOT (EQ (CL:CAR ~G287) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G287)))) (CL:LABELS ((~G1793 (TOKEN) (CL:LABELS ((~G1794 (~G289) (CL:LABELS ((~G1795 (PKG) (CL:LABELS ((~G1796 (~G290) (CL:LABELS ((~G1797 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1797 (CL:CAR ~G290))))) (~G1796 (CL:LABELS ((~G1798 (~G293) (CL:COND (~G293 ~G293) (T (%ERROR "Not enough VALUES."))))) (~G1798 (CL:CDR ~G289))))))) (~G1795 (CL:CAR ~G289))))) (~G1794 (CL:LABELS ((~G1799 (~G292) (CL:COND (~G292 ~G292) (T (%ERROR "Not enough VALUES."))))) (~G1799 (CL:CDR ~G288))))))) (~G1793 (CL:CAR ~G288))))) (~G1792 (CL:CDR ~G287))))) (~G1791 (READ-TOKEN STR)))))) (~G1764 (STREAM-LOCATION-ID LOC))))) (~G1763 (STREAM-LOCATION-COLUMN LOC))))) (~G1762 (STREAM-LOCATION-LINE LOC))))) (~G1761 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1800 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G1801 (~G240) (CL:COND (~G240 ~G240) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1801 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1800 (EQ X 'BRACKET-CLOSE))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1802 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1802 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1803 (~G222) (CL:COND (~G222 ~G222) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1803 (HREF *MEMORIZED-NUMBERS* X))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1804 (~G261) (CL:LABELS ((~G1805 (~G262) (CL:COND ((NOT (EQ (CL:CAR ~G261) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G261)))) (CL:LABELS ((~G1806 (PKG) (CL:LABELS ((~G1807 (~G263) (CL:LABELS ((~G1808 (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 ((~G1809 (~G260) (CL:COND ((CHARACTER== ~G260 #\() 'BRACKET-OPEN) ((CHARACTER== ~G260 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G260 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G260 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G260 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G260 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G260 #\') 'CL:QUOTE) ((CHARACTER== ~G260 #\`) 'BACKQUOTE) ((CHARACTER== ~G260 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G260 #\") 'DBLQUOTE) ((CHARACTER== ~G260 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G260 #\#) (CL:LABELS ((~G1810 (~G259) (CL:COND ((CHARACTER== ~G259 #\\) 'CHAR) ((CHARACTER== ~G259 #\x) 'HEXNUM) ((CHARACTER== ~G259 #\') 'CL:FUNCTION) ((CHARACTER== ~G259 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1810 (READ-CHAR STR)))) ((CHARACTER== ~G260 -1) 'EOF)))) (~G1809 (READ-CHAR STR))))))) PKG SYM))) (~G1808 (CL:CAR ~G263))))) (~G1807 (CL:LABELS ((~G1811 (~G265) (CL:COND (~G265 ~G265) (T (%ERROR "Not enough VALUES."))))) (~G1811 (CL:CDR ~G262))))))) (~G1806 (CL:CAR ~G262))))) (~G1805 (CL:CDR ~G261))))) (~G1804 (GET-SYMBOL-AND-PACKAGE STR))))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G255 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G255)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1812 (~G257) (CL:COND (~G257 ~G257) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1812 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1813 (~G256) (CL:COND (~G256 ~G256) (T (== #\. (CL:CAR X)))))) (~G1813 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1814 (~G258) (CL:COND (~G258 ~G258) (T (== #\. _))))) (~G1814 (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 ((~G1815 (~G108) (CL:LABELS ((~G1816 (SEQ) (CL:TAGBODY ~G106 (CL:COND ((NOT ~G108) (CL:GO ~G107))) (CL:SETQ SEQ (CL:CAR ~G108)) (CL:LABELS ((~G1817 (~G105) (CL:BLOCK NIL (CL:LABELS ((~G1818 (!) (CL:TAGBODY ~G109 (CL:COND ((INTEGER== ! ~G105) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1819 (~G104) (CL:COND (~G104 ~G104) (T (CL:RETURN-FROM EVERY NIL))))) (~G1819 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G109)))) (~G1818 0))))) (~G1817 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G108 (CL:CDR ~G108)) (CL:GO ~G106) ~G107 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1816 NIL)))) (~G1815 SEQS))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1820 (SYM) (CL:LABELS ((~G1821 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1822 (~G254) (CL:COND (~G254 ~G254) (T T)))) (~G1822 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1821 (PEEK-CHAR STR))))) (~G1820 (GET-SYMBOL STR))))))
  (CL:DEFUN GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1823 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1823 (PEEK-CHAR STR))))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1824 (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)))))))) (~G1824 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1825 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1825 (READ-CHAR STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1826 (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))))))))) (~G1826 (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 ((~G1827 (~G224) (CL:COND (~G224 ~G224) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1827 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G885 (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 ((~G1828 (~G883) (CL:COND ((CL:ATOM ~G883) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G883) (QQ _)) ((QUASIQUOTE-SPLICE? ~G883) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1828 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1829 (~G884) (CL:COND ((QUOTE? ~G884) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G884) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1829 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING #'DISP))))) (CL:COND ((NOT (DUMP-PASS? 'QUOTE-EXPAND)) (CL:PROGN (CL:RETURN-FROM NIL (~G885 X))))) (FRESH-LINE) (FORMAT T "; **** QUOTE-EXPAND~%") (CL:LABELS ((~G1830 (~G886) (FRESH-LINE) (FORMAT T "; **** end of QUOTE-EXPAND~%") ~G886)) (~G1830 (CL:LABELS ((~G1831 (~G887) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* X)) (CL:LABELS ((~G1832 (~G889) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* ~G887)) ~G889)) (~G1832 (CL:PROGN (CL:LABELS ((~G1833 (~G888) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* T)) (CL:LABELS ((~G1834 (~G890) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* ~G888)) ~G890)) (~G1834 (CL:PROGN (LATE-PRINT (~G885 X))))))) (~G1833 *ALWAYS-PRINT-PACKAGE-NAMES?*))))))) (~G1831 *CURRENT-PASS-INPUT*))))))))
  (CL:DEFUN DUMP-PASS? (NAME) (CL:BLOCK DUMP-PASS? (CL:BLOCK NIL (CL:COND (*TRANSPILER* (CL:LABELS ((~G1835 (!) (CL:COND (! (CL:LABELS ((~G1836 (~G418) (CL:COND (~G418 ~G418) (T (MEMBER NAME (ENSURE-LIST !)))))) (~G1836 (EQ T !))))))) (~G1835 (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 ((~G1837 (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)))) (~G1837 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 ((~G1838 (Y) (CL:LABELS ((~G1839 (A) (CL:PROGN (CL:LABELS ((~G1840 (~G362) (CL:LABELS ((~G1841 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1841 (CL:COND ((CONS? ~G362) (CPR ~G362))))))) (~G1840 I)) (CL:LABELS ((~G1842 (~G361) (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)) ~G361))) (~G1842 *DEFAULT-LISTPROP*))))) (~G1839 (CL:LABELS ((~G1843 (~G360) (CL:COND (~G360 ~G360) (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))))))) (~G1843 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1838 (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 ((~G1844 (~G409) (CL:COND (~G409 ~G409) (T (CL:LABELS ((~G1845 (~G410) (CL:COND (~G410 ~G410) (T (CL:LABELS ((~G1846 (~G411) (CL:COND (~G411 ~G411) (T (CL:LABELS ((~G1847 (~G412) (CL:COND (~G412 ~G412) (T (CL:LABELS ((~G1848 (~G413) (CL:COND (~G413 ~G413) (T (HASH-TABLE? X))))) (~G1848 (ARRAY? X))))))) (~G1847 (STRING? X))))))) (~G1846 (NUMBER? X))))))) (~G1845 (EQ T X))))))) (~G1844 (NOT X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1849 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1849 (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 ((~G1850 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1850 (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 ((~G1851 (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)))))))) (~G1851 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFVAR *GENSYM-PREFIX*)
  
negative.code: (CL:PROGN (CL:DEFUN %NCONC (CL:&REST X) X (CL:APPLY #'CL:NCONC X)) (CL:SETF (CL:GETHASH '%NCONC *BUILTIN-ATOMS*) #'%NCONC))
  (CL:PROGN (CL:DEFUN APPEND (CL:&REST X) X (CL:APPLY #'CL:NCONC (CL:MAPCAR #'CL:COPY-LIST X))) (CL:SETF (CL:GETHASH 'APPEND *BUILTIN-ATOMS*) #'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 ((~G1509 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1509 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  (CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1510 (~G1461) (CL:LABELS ((~G1511 (I) (CL:TAGBODY ~G1459 (CL:COND ((NOT ~G1461) (CL:GO ~G1460))) (CL:SETQ I (CL:CAR ~G1461)) (EVAL (%EXPAND I)) (CL:SETQ ~G1461 (CL:CDR ~G1461)) (CL:GO ~G1459) ~G1460 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1511 NIL)))) (~G1510 (CL:LABELS ((~G1512 (S) (CL:LABELS ((~G1513 (~G1458) (CLOSE S) ~G1458)) (~G1513 (CL:PROGN (%LOAD-R S)))))) (~G1512 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) #'LOAD))
  (CL:DEFUN ENV-MACROS NIL (SYMBOL-VALUE (TRE-SYMBOL '*MACROS*)))
  (CL:PROGN (CL:DEFUN MACRO? (X) (CL:RASSOC X (ENV-MACROS) :TEST #'EQ)) (CL:SETF (CL:GETHASH 'MACRO? *BUILTIN-ATOMS*) #'MACRO?))
  (CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G1514 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G1514 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST #'EQ))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) #'%%MACROCALL))
  (CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G1515 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST #'EQ))))) (~G1515 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) #'%%MACRO?))
  (CL:DEFVAR *MACROEXPAND*)
  (CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G1516 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1516 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) #'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*) #'MACROEXPAND))
  (CL:PROGN (CL:DEFUN QUIT (CL:&OPTIONAL EXIT-CODE) (SB-EXT:QUIT :UNIX-STATUS EXIT-CODE)) (CL:SETF (CL:GETHASH 'QUIT *BUILTIN-ATOMS*) #'QUIT))
  (CL:PROGN (CL:DEFUN NANOTIME NIL 0) (CL:SETF (CL:GETHASH 'NANOTIME *BUILTIN-ATOMS*) #'NANOTIME))
  (CL:PROGN (CL:DEFUN NUMBER? (X) (CL:LABELS ((~G1517 (~G1462) (CL:COND (~G1462 ~G1462) (T (CL:CHARACTERP X))))) (~G1517 (CL:NUMBERP X)))) (CL:SETF (CL:GETHASH 'NUMBER? *BUILTIN-ATOMS*) #'NUMBER?))
  (CL:PROGN (CL:DEFUN INTEGER (X) (CL:FLOOR X)) (CL:SETF (CL:GETHASH 'INTEGER *BUILTIN-ATOMS*) #'INTEGER))
  (CL:DEFUN CHARS-TO-NUMBERS (X) (CL:MAPCAR (CL:LAMBDA (X) (CL:COND ((CL:CHARACTERP X) (CL:CHAR-CODE X)) (T X))) X))
  (CL:PROGN (CL:DEFUN == (CL:&REST X) (CL:APPLY #'CL:= (CHARS-TO-NUMBERS X))) (CL:SETF (CL:GETHASH '== *BUILTIN-ATOMS*) #'==))
  