anchor.diff:  (CL:DEFVAR *QUASIQUOTE-EXPAND*)
   (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1348 (~G1302) (CL:COND (~G1302 ~G1302) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1348 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1110 (~G1059) (CL:COND (~G1059 ~G1059) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1110 (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:&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*) (CL:FUNCTION ENV-LOAD)))
  -(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1349 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1349 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1350 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1350 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1111 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1111 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1112 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1112 (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 ((~G1351 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1352 (~G1304) (CL:COND ((INTEGER< ~G1304 0) (ERROR "Negative number of iterations: ~A." ~G1304))) (CL:BLOCK NIL (CL:LABELS ((~G1353 (!) (CL:TAGBODY ~G1305 (CL:COND ((INTEGER== ! ~G1304) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1305)))) (~G1353 0))))) (~G1352 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1351 (CL:LABELS ((~G1354 (~G1303) (CL:COND (~G1303 ~G1303) (T CL:*STANDARD-OUTPUT*)))) (~G1354 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1113 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1114 (~G1061) (CL:COND ((INTEGER< ~G1061 0) (ERROR "Negative number of iterations: ~A." ~G1061))) (CL:BLOCK NIL (CL:LABELS ((~G1115 (!) (CL:TAGBODY ~G1062 (CL:COND ((INTEGER== ! ~G1061) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1062)))) (~G1115 0))))) (~G1114 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1113 (CL:LABELS ((~G1116 (~G1060) (CL:COND (~G1060 ~G1060) (T CL:*STANDARD-OUTPUT*)))) (~G1116 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 ((~G1355 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1355 (CL:READ-BYTE (CL:LABELS ((~G1356 (~G1306) (CL:COND (~G1306 ~G1306) (T CL:*STANDARD-INPUT*)))) (~G1356 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1117 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1117 (CL:READ-BYTE (CL:LABELS ((~G1118 (~G1063) (CL:COND (~G1063 ~G1063) (T CL:*STANDARD-INPUT*)))) (~G1118 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %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*) (CL:FUNCTION UNIX-SH-MKDIR)))
   (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*)
  
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 ((~G1599 (~G184) (CL:COND (~G184 ~G184) (T (CL:LABELS ((~G1600 (~G185) (CL:COND (~G185 ~G185) (T (CL:LABELS ((~G1601 (~G186) (CL:COND (~G186 ~G186) (T (EQ X 'CL:&KEY))))) (~G1601 (EQ X 'CL:&OPTIONAL))))))) (~G1600 (EQ X 'CL:&BODY))))))) (~G1599 (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 ((~G1602 (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 ((~G1603 (!) (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 _)))) (~G1603 (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))))) (~G1602 NIL)))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1604 (!) (CL:BLOCK NIL (CL:LABELS ((~G1605 (~G41) (CL:LABELS ((~G1606 (I) (CL:TAGBODY ~G39 (CL:COND ((NOT ~G41) (CL:GO ~G40))) (CL:SETQ I (CL:CAR ~G41)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G41 (CL:CDR ~G41)) (CL:GO ~G39) ~G40 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G1606 NIL)))) (~G1605 LST))))) (~G1604 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1607 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1607 (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 NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (++ (* SIZE (++ (INTEGER (/ (-- COLUMN) SIZE))))))))
  (CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN =-STREAM-LOCATION-COLUMN (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN STREAM-LOCATION-TABSIZE (ARR) (CL:BLOCK STREAM-LOCATION-TABSIZE (CL:BLOCK NIL (CL:AREF ARR 6))))
  (CL:DEFUN READ-STRING-0 (STR) (CL:BLOCK READ-STRING-0 (CL:BLOCK NIL (CL:LABELS ((~G1608 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1608 (READ-CHAR STR))))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1609 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1609 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1610 (~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)) (~G1610 (CL:CAR (CL:CDR X)))))))
  (CL:DEFUN ENQUEUE-LIST (X VALS) (CL:BLOCK ENQUEUE-LIST (CL:BLOCK NIL (CL:RPLACD X (NCONC (CL:CDR X) VALS)) (CL:RPLACA X (CL:LAST VALS)))))
  (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 ((~G1611 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1611 (CL:MOD X 1))))))
  (CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1612 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1612 (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 ((~G1613 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1613 (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 32) (NOT (SPECIAL-CHAR? X)))))))
  (CL:DEFUN - (CL:&REST X) (CL:APPLY (CL:FUNCTION NUMBER-) X))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1614 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1615 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1615 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1614 (DIGIT-CHAR? X))))))
  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CHARACTER+ C (CHARACTER- #\A #\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 MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1616 (~G232) (CL:COND (~G232 ~G232) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1616 (HREF *MEMORIZED-NUMBERS* X))))))
  (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 GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1617 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1617 (PEEK-CHAR STR))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1618 (~G109) (CL:LABELS ((~G1619 (SEQ) (CL:TAGBODY ~G107 (CL:COND ((NOT ~G109) (CL:GO ~G108))) (CL:SETQ SEQ (CL:CAR ~G109)) (CL:LABELS ((~G1620 (~G110) (CL:COND ((INTEGER< ~G110 0) (ERROR "Negative number of iterations: ~A." ~G110))) (CL:BLOCK NIL (CL:LABELS ((~G1621 (!) (CL:TAGBODY ~G111 (CL:COND ((INTEGER== ! ~G110) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1622 (~G106) (CL:COND (~G106 ~G106) (T (CL:RETURN-FROM EVERY NIL))))) (~G1622 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G111)))) (~G1621 0))))) (~G1620 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G109 (CL:CDR ~G109)) (CL:GO ~G107) ~G108 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1619 NIL)))) (~G1618 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1623 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1623 (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 ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  (CL:DEFVAR *MEMORIZED-NUMBERS*)
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G1624 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1624 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X #\0 #\9))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1625 (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)))))))) (~G1625 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (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 ((~G1626 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1626 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1627 (~G70) (CL:LABELS ((~G1628 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1629 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1629 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1628 NIL)))) (~G1627 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1630 (~G18) (CL:LABELS ((~G1631 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1632 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1633 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1633 (< N I))))))) (~G1632 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1631 NIL)))) (~G1630 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1634 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1635 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1636 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1637 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G1638 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1639 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G1640 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1641 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1642 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1643 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1644 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1645 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1646 (~G263) (CL:COND (~G263 ~G263) (T (== X #\^))))) (~G1646 (== X #\#))))))) (~G1645 (== X #\"))))))) (~G1644 (== X #\;))))))) (~G1643 (== X #\:))))))) (~G1642 (== X #\,))))))) (~G1641 (== X #\`))))))) (~G1640 (== X #\'))))))) (~G1639 (== X #\}))))))) (~G1638 (== X #\{))))))) (~G1637 (== X #\]))))))) (~G1636 (== X #\[))))))) (~G1635 (== X #\)))))))) (~G1634 (== 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 ((~G1647 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1647 (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 FRACTION-CHARS (X) (CL:BLOCK FRACTION-CHARS (CL:BLOCK NIL (FRACTION-CHARS-0 (CL:MOD (ABS X) 1)))))
  (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 ((~G1648 (E) (CL:LABELS ((~G1649 (S) (CL:COND ((CL:LABELS ((~G1650 (~G103) (CL:COND (~G103 ~G103) (T (CL:COND ((< S E) FROM-END)))))) (~G1650 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1651 (~G104) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G104)))) (~G1651 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1652 (I) (CL:TAGBODY ~G105 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1653 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1653 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G105)))) (~G1652 S))))) (~G1649 (CL:LABELS ((~G1654 (~G102) (CL:COND (~G102 ~G102) (T 0)))) (~G1654 START)))))) (~G1648 (CL:LABELS ((~G1655 (~G101) (CL:COND (~G101 ~G101) (T (-- (CL:LENGTH SEQ)))))) (~G1655 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1656 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1657 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1658 (~G100) (CL:LABELS ((~G1659 (!) (CL:TAGBODY ~G98 (CL:COND ((NOT ~G100) (CL:GO ~G99))) (CL:SETQ ! (CL:CAR ~G100)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G100 (CL:CDR ~G100)) (CL:GO ~G98) ~G99 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1659 NIL)))) (~G1658 !))))) (~G1657 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1660 (~G97) (CL:LABELS ((~G1661 (!) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ ! (CL:CAR ~G97)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1661 NIL)))) (~G1660 !))))))) (~G1656 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1662 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1662 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1663 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1663 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- X #\0))))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  
negative.code: (CL:PROGN (CL:DEFUN NUMBER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'NUMBER> *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER>)))
  (CL:PROGN (CL:DEFUN INTEGER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'INTEGER> *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER>)))
  (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1150 (TESTS) (CL:LABELS ((~G1151 (END) (CL:COND ((NOT BODY) (CL:PROGN (ERROR "Body is missing.")))) (CL:CONS 'CL:COND (APPEND (CL:COND ((SOLE? END) (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END)))) (T TESTS)) NIL)))) (~G1151 (CL:CAR (CL:LAST TESTS)))))) (~G1150 (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 ((~G1152 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1152 (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 FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  (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 ((~G1153 (~G131) (CL:LABELS ((~G1154 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (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 ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1154 NIL)))) (~G1153 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 ((~G1155 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1155 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  (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:PROGN (CL:LABELS ((~G1156 (~G125) (CL:LABELS ((~G1157 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1157 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1156 X)) (CL:LABELS ((~G1158 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1158 *DEFAULT-LISTPROP*)))) (T 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 PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1159 (~G234) (CL:COND (~G234 ~G234) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1159 (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 ((~G1160 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1161 (~G335) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G334)) ~G335)) (~G1161 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1160 *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 ((~G1162 (~G734) (CL:COND ((CL:ATOM ~G734) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G734) (QQ _)) ((QUASIQUOTE-SPLICE? ~G734) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1162 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1163 (~G735) (CL:COND ((QUOTE? ~G735) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G735) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1163 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING (CL:FUNCTION DISP)))))))
  (CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((== _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1164 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1164 (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 ((~G1165 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1165 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1166 (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)))))))) (~G1166 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-PREFIX*)
  (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
  