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:LABELS ((~G1512 (~G1466) (CL:COND (~G1466 ~G1466) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1512 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) #'BUILTIN?))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1458 (~G1412) (CL:COND (~G1412 ~G1412) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1458 (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 ((~G1513 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1513 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1514 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1514 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1459 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1459 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1460 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1460 (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 ((~G1515 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1516 (~G1468) (CL:COND ((INTEGER< ~G1468 0) (ERROR "Negative number of iterations: ~A."  ~G1468))) (CL:BLOCK NIL (CL:LABELS ((~G1517 (!) (CL:TAGBODY ~G1469 (CL:COND ((INTEGER== ! ~G1468) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1469)))) (~G1517 0))))) (~G1516 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1515 (CL:LABELS ((~G1518 (~G1467) (CL:COND (~G1467 ~G1467) (T CL:*STANDARD-OUTPUT*)))) (~G1518 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1461 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1462 (~G1414) (CL:COND ((INTEGER< ~G1414 0) (ERROR "Negative number of iterations: ~A."  ~G1414))) (CL:BLOCK NIL (CL:LABELS ((~G1463 (!) (CL:TAGBODY ~G1415 (CL:COND ((INTEGER== ! ~G1414) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1415)))) (~G1463 0))))) (~G1462 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1461 (CL:LABELS ((~G1464 (~G1413) (CL:COND (~G1413 ~G1413) (T CL:*STANDARD-OUTPUT*)))) (~G1464 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 ((~G1519 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1519 (CL:READ-BYTE (CL:LABELS ((~G1520 (~G1470) (CL:COND (~G1470 ~G1470) (T CL:*STANDARD-INPUT*)))) (~G1520 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1465 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1465 (CL:READ-BYTE (CL:LABELS ((~G1466 (~G1416) (CL:COND (~G1416 ~G1416) (T CL:*STANDARD-INPUT*)))) (~G1466 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: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 ((~G1521 (~G1471) (CL:COND (~G1471 ~G1471) (T (CL:EQ TEST #'==))))) (~G1521 (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 ((~G1467 (~G1417) (CL:COND (~G1417 ~G1417) (T (CL:EQ TEST #'==))))) (~G1467 (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 ((~G1522 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1522 (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 ((~G1523 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1523 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'HASHKEYS))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1468 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1468 (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 ((~G1469 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1469 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 ((~G1524 (~G1473) (CL:COND (~G1473 ~G1473) (T NIL)))) (~G1524 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 ((~G1470 (~G1419) (CL:COND (~G1419 ~G1419) (T NIL)))) (~G1470 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:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (== 0 X))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1603 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1603 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:LABELS ((~G1604 (~G222) (CL:COND ((CONS? ~G222) (%PRINT-CONS X STR INFO)) ((SYMBOL? ~G222) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G222) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G222) (PRINC X STR)) ((STRING? ~G222) (%PRINT-STRING X STR)) ((ARRAY? ~G222) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G222) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G222) (%PRINT-OBJECT X STR INFO)) (T (%ERROR "Don't know how to print object."))))) (~G1604 X))))))
  (CL:DEFUN %PRINT-OBJECT (X STR INFO) (CL:BLOCK %PRINT-OBJECT (CL:BLOCK NIL)))
  (CL:DEFUN OBJECT? (X) (CL:BLOCK OBJECT? (CL:BLOCK NIL X NIL)))
  (CL:DEFUN %PRINT-FUNCTION (X STR INFO) (CL:BLOCK %PRINT-FUNCTION (CL:BLOCK NIL (PRINC "#'" STR) (%LATE-PRINT (CL:CONS (FUNCTION-ARGUMENTS X) (FUNCTION-BODY X)) STR INFO))))
  (CL:DEFUN FUNCTION-BODY (FUN) (CL:BLOCK FUNCTION-BODY (CL:BLOCK NIL (CL:COND ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 1)) (T (CL:CDR (FUNCTION-SOURCE FUN)))))))
  (CL:DEFUN FUNCTION-ARGUMENTS (FUN) (CL:BLOCK FUNCTION-ARGUMENTS (CL:BLOCK NIL (CL:COND ((BUILTIN? FUN) (CL:CONS 'CL:&REST (CL:CONS 'ARGS-TO-BUILTIN NIL))) ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 0)) (T (CL:CAR (FUNCTION-SOURCE FUN)))))))
  (CL:DEFUN %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (CL:LABELS ((~G1605 (~G218) (CL:COND (~G218 (CL:PROGN (CL:LABELS ((~G1606 (~G220) (CL:COND ((INTEGER< ~G220 0) (ERROR "Negative number of iterations: ~A."  ~G220))) (CL:BLOCK NIL (CL:LABELS ((~G1607 (~G219) (CL:TAGBODY ~G221 (CL:COND ((INTEGER== ~G219 ~G220) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1608 (I) (%LATE-PRINT I STR INFO))) (~G1608 (CL:AREF ~G218 ~G219))) (CL:SETQ ~G219 (INTEGER+ 1 ~G219)) (CL:GO ~G221)))) (~G1607 0))))) (~G1606 (INTEGER (CL:LENGTH ~G218))))))))) (~G1605 X)) (PRINC ")" STR)))))
  (CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G1609 (~G209) (CL:LABELS ((~G1610 (I) (CL:TAGBODY ~G207 (CL:COND ((NOT ~G209) (CL:GO ~G208))) (CL:SETQ I (CL:CAR ~G209)) (CL:COND ((== I #\") (PRINC "\\\"" STR)) ((== I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G209 (CL:CDR ~G209)) (CL:GO ~G207) ~G208 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1610 NIL)))) (~G1609 (STRING-LIST X)))) (PRINC #\" STR))))
  (CL:DEFUN %PRINT-CHARACTER (X STR) (CL:BLOCK %PRINT-CHARACTER (CL:BLOCK NIL (PRINC "#\\" STR) (PRINC X STR))))
  (CL:DEFUN %PRINT-SYMBOL (X STR INFO) (CL:BLOCK %PRINT-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1611 (!) (CL:COND (! (CL:PROGN (CL:COND ((NOT (INVISIBLE-PACKAGE-NAME? X)) (CL:PROGN (CL:LABELS ((~G1612 (~G217) (CL:COND (~G217 ~G217) (T (%PRINT-SYMBOL-PACKAGE (CL:PACKAGE-NAME !) STR))))) (~G1612 (KEYWORD? X))) (PRINC #\: STR))))))))) (~G1611 (CL:COND (X (CL:COND ((NOT (EQ T X)) (SYMBOL-PACKAGE X))))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
  (CL:DEFUN %PRINT-SYMBOL-COMPONENT (X STR) (CL:BLOCK %PRINT-SYMBOL-COMPONENT (CL:BLOCK NIL (CL:COND ((SOME #'SYMBOL-CHAR-NEEDS-ESCAPING?  (STRING-LIST X)) (%PRINT-ESCAPED-SYMBOL X STR)) (T (PRINC X STR))))))
  (CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G1613 (~G212) (CL:LABELS ((~G1614 (I) (CL:TAGBODY ~G210 (CL:COND ((NOT ~G212) (CL:GO ~G211))) (CL:SETQ I (CL:CAR ~G212)) (CL:COND ((== I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G212 (CL:CDR ~G212)) (CL:GO ~G210) ~G211 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1614 NIL)))) (~G1613 (STRING-LIST X)))) (PRINC #\| STR))))
  (CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G1615 (~G213) (CL:COND (~G213 ~G213) (T (LOWER-CASE?  X))))) (~G1615 (== #\| X))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G64) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1616 (~G68) (CL:LABELS ((~G1617 (C) (CL:TAGBODY ~G66 (CL:COND ((NOT ~G68) (CL:GO ~G67))) (CL:SETQ C (CL:CAR ~G68)) (CL:LABELS ((~G1618 (~G65) (CL:COND (~G65 ~G65) (T (CL:RETURN-FROM NIL NIL))))) (~G1618 (RANGE? C #\a #\z))) (CL:SETQ ~G68 (CL:CDR ~G68)) (CL:GO ~G66) ~G67 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1617 NIL)))) (~G1616 ~G64))))))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X  BOTTOM) (<= X  TOP))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1619 (~G18) (CL:LABELS ((~G1620 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1621 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1622 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1622 (< N I))))))) (~G1621 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1620 NIL)))) (~G1619 X))))))
  (CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1623 (~G13) (CL:LABELS ((~G1624 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1625 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1626 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1626 (> N I))))))) (~G1625 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1624 NIL)))) (~G1623 X))))))
  (CL:DEFUN SOME (PRED CL:&REST SEQS) (CL:BLOCK SOME (CL:BLOCK NIL (FIND-IF PRED (CL:APPLY #'APPEND SEQS) :START NIL :END NIL :FROM-END NIL :WITH-INDEX NIL))))
  (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 %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 ((~G1627 (E) (CL:LABELS ((~G1628 (S) (CL:COND ((CL:LABELS ((~G1629 (~G101) (CL:COND (~G101 ~G101) (T (CL:COND ((< S E) FROM-END)))))) (~G1629 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1630 (~G102) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G102)))) (~G1630 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1631 (I) (CL:TAGBODY ~G103 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1632 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1632 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G103)))) (~G1631 S))))) (~G1628 (CL:LABELS ((~G1633 (~G100) (CL:COND (~G100 ~G100) (T 0)))) (~G1633 START)))))) (~G1627 (CL:LABELS ((~G1634 (~G99) (CL:COND (~G99 ~G99) (T (-- (CL:LENGTH SEQ)))))) (~G1634 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1635 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1636 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1637 (~G95) (CL:LABELS ((~G1638 (!) (CL:TAGBODY ~G93 (CL:COND ((NOT ~G95) (CL:GO ~G94))) (CL:SETQ ! (CL:CAR ~G95)) (CL:COND ((FUNCALL PRED  ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G95 (CL:CDR ~G95)) (CL:GO ~G93) ~G94 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1638 NIL)))) (~G1637 !))))) (~G1636 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1639 (~G98) (CL:LABELS ((~G1640 (!) (CL:TAGBODY ~G96 (CL:COND ((NOT ~G98) (CL:GO ~G97))) (CL:SETQ ! (CL:CAR ~G98)) (CL:COND ((FUNCALL PRED  !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G98 (CL:CDR ~G98)) (CL:GO ~G96) ~G97 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1640 NIL)))) (~G1639 !))))))) (~G1635 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1641 (!) (CL:BLOCK NIL (CL:LABELS ((~G1642 (~G39) (CL:LABELS ((~G1643 (I) (CL:TAGBODY ~G37 (CL:COND ((NOT ~G39) (CL:GO ~G38))) (CL:SETQ I (CL:CAR ~G39)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G39 (CL:CDR ~G39)) (CL:GO ~G37) ~G38 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G1643 NIL)))) (~G1642 LST))))) (~G1641 NIL)))))
  (CL:DEFUN %PRINT-SYMBOL-PACKAGE (NAME STR) (CL:BLOCK %PRINT-SYMBOL-PACKAGE (CL:BLOCK NIL (%PRINT-SYMBOL-COMPONENT (ABBREVIATED-PACKAGE-NAME NAME) STR))))
  (CL:DEFUN ABBREVIATED-PACKAGE-NAME (X) (CL:BLOCK ABBREVIATED-PACKAGE-NAME (CL:BLOCK NIL (CL:COND ((STRING== "COMMON-LISP" X) "CL") (T X)))))
  (CL:DEFUN INVISIBLE-PACKAGE-NAME? (X) (CL:BLOCK INVISIBLE-PACKAGE-NAME? (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G1644 (~G214) (CL:COND (~G214 ~G214) (T (CL:LABELS ((~G1645 (~G215) (CL:COND (~G215 ~G215) (T *ALWAYS-PRINT-PACKAGE-NAMES?*)))) (~G1645 (EQ T X))))))) (~G1644 (NOT X)))) (CL:PROGN (CL:LABELS ((~G1646 (!) (CL:LABELS ((~G1647 (~G216) (CL:COND (~G216 ~G216) (T (STRING== ! "TRE-CORE"))))) (~G1647 (STRING== ! "TRE"))))) (~G1646 (CL:PACKAGE-NAME (SYMBOL-PACKAGE X))))))))))
  (CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G1648 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G1648 (CL:COND ((CONS? (CL:CDR X)) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST #'EQ))))))))))
  (CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G1649 (!) (CL:COND (! (%PRINT-CALL (CL:CDR X) ! STR INFO)) (T (%PRINT-REST (CL:CDR X) STR INFO))))) (~G1649 (%PRINT-CALL? X INFO))) (PRINC ")" STR)))))
  (CL:DEFUN %PRINT-REST (X STR INFO) (CL:BLOCK %PRINT-REST (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:PROGN (%PRINT-GAP STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO))) (T (CL:PROGN (PRINC " . " STR) (%LATE-PRINT X STR INFO))))))))))
  (CL:DEFUN %PRINT-GAP (STR) (CL:BLOCK %PRINT-GAP (CL:BLOCK NIL (CL:LABELS ((~G1650 (~G194) (CL:COND (~G194 ~G194) (T (PRINC " " STR))))) (~G1650 (FRESH-LINE? STR))))))
  (CL:DEFUN %PRINT-CALL (X ARGDEF STR INFO) (CL:BLOCK %PRINT-CALL (CL:BLOCK NIL (%PRINT-ARGS (%PRINT-GET-ARGS X ARGDEF) STR INFO))))
  (CL:DEFUN %PRINT-GET-ARGS (ARGS DEF) (CL:BLOCK %PRINT-GET-ARGS (CL:BLOCK NIL (ARGUMENT-EXPAND 'CL:PRINT DEF ARGS :APPLY-VALUES? T :CONCATENATE-SUBLISTS? NIL :BREAK-ON-ERRORS? NIL))))
  (CL:DEFUN %PRINT-ARGS (X STR INFO) (CL:BLOCK %PRINT-ARGS (CL:BLOCK NIL (CL:COND ((EQ X 'ERROR) (%PRINT-REST X STR INFO)) (T (CL:BLOCK NIL (CL:LABELS ((~G1651 (~G206) (CL:LABELS ((~G1652 (!) (CL:TAGBODY ~G204 (CL:COND ((NOT ~G206) (CL:GO ~G205))) (CL:SETQ ! (CL:CAR ~G206)) (%PRINT-GAP STR) (CL:COND ((NOT (CL:CAR !)) (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC "(" STR) (%PRINT-ARGS (CL:CDR !) STR INFO) (PRINC ")" STR))) ((%BODY? (CL:CDR !)) (%PRINT-BODY (CL:CDR (CL:CDR !)) STR INFO)) ((%REST? (CL:CDR !)) (%PRINT-REST (CL:CDR (CL:CDR !)) STR INFO)) ((%KEY? (CL:CDR !)) (CL:PROGN (%PRINT-SYMBOL (MAKE-KEYWORD (CL:CAR !)) STR INFO) (PRINC " " STR) (%LATE-PRINT (CL:CDR (CL:CDR !)) STR INFO))) (T (CL:LABELS ((~G1653 (~G202) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1654 (~G203) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G202)) ~G203)) (~G1654 (CL:PROGN (%LATE-PRINT (CL:CDR !) STR INFO)))))) (~G1653 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G206 (CL:CDR ~G206)) (CL:GO ~G204) ~G205 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1652 NIL)))) (~G1651 X))))))))
  (CL:DEFUN MAKE-KEYWORD (X) (CL:BLOCK MAKE-KEYWORD (CL:BLOCK NIL (MAKE-SYMBOL (CL:COND ((SYMBOL? X) (SYMBOL-NAME X)) (T X)) *KEYWORD-PACKAGE*))))
  (CL:DEFUN %KEY? (X) (CL:BLOCK %KEY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%KEY (CL:CAR X)) X)))))))
  (CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
  (CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
  (CL:DEFUN %PRINT-CALL? (X INFO) (CL:BLOCK %PRINT-CALL? (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G1655 (!) (CL:COND ((BUILTIN? (CL:CAR X)) NIL) ((FUNCTION? !) (FUNCTION-ARGUMENTS (CL:CAR X)))))) (~G1655 (SYMBOL-FUNCTION (CL:CAR X)))))))))))
  (CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN %PRINT-ABBREVIATION (ABBREVIATION X STR INFO) (CL:BLOCK %PRINT-ABBREVIATION (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC (CL:CAR (CL:CDR ABBREVIATION)) STR) (%LATE-PRINT (CL:CAR (CL:CDR X)) STR INFO)))))
  (CL:DEFUN %PRINT-INDENTATION (STR INFO) (CL:BLOCK %PRINT-INDENTATION (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((FRESH-LINE? STR) (CL:LABELS ((~G1656 (~G195) (CL:COND ((INTEGER< ~G195 0) (ERROR "Negative number of iterations: ~A."  ~G195))) (CL:BLOCK NIL (CL:LABELS ((~G1657 (!) (CL:TAGBODY ~G196 (CL:COND ((INTEGER== ! ~G195) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G196)))) (~G1657 0))))) (~G1656 (INTEGER (PRINT-INFO-INDENTATION INFO)))))))))))
  (CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (CL:LABELS ((~G1658 (~G197) (CL:PROGN (=-PRINT-INFO-INDENTATION (++ (PRINT-INFO-INDENTATION INFO)) INFO)) (CL:LABELS ((~G1659 (~G201) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G197 INFO)) ~G201)) (~G1659 (CL:PROGN (CL:BLOCK NIL (CL:LABELS ((~G1660 (~G200) (CL:LABELS ((~G1661 (!) (CL:TAGBODY ~G198 (CL:COND ((NOT ~G200) (CL:GO ~G199))) (CL:SETQ ! (CL:CAR ~G200)) (FRESH-LINE STR) (%LATE-PRINT ! STR INFO) (CL:SETQ ~G200 (CL:CDR ~G200)) (CL:GO ~G198) ~G199 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1661 NIL)))) (~G1660 X)))))))) (~G1658 (PRINT-INFO-INDENTATION INFO))))))
  (CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1662 (~G177) (CL:LABELS ((~G1663 (S) (CL:LABELS ((~G1664 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1664 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1663 (DEFAULT-STREAM ~G177))))) (~G1662 STR)))))
  (CL:DEFUN =-PRINT-INFO-INDENTATION (VAL ARR) (CL:BLOCK =-PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1665 (~G193) (CL:PROGN (=-AREF 'STRUCT ~G193 0) (=-AREF 'PRINT-INFO ~G193 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) T) (T PRETTY-PRINT?)) ~G193 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G193 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G193 4)) ~G193)) (~G1665 (MAKE-ARRAY 5))))))
  (CL:DEFUN %FORMAT-DIRECTIVE-EOL (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-EOL (CL:BLOCK NIL (TERPRI (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
  (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 FORMAT-INFO-PROCESSED-ARGS (ARR) (CL:BLOCK FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN =-FORMAT-INFO-PROCESSED-ARGS (VAL ARR) (CL:BLOCK =-FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1666 (~G173) (CL:LABELS ((~G1667 (S) (CL:LABELS ((~G1668 (~G174) (CL:COND (~G173 ~G174) (T (GET-STREAM-STRING S))))) (~G1668 (CL:PROGN (CL:COND ((STRING? X) (STREAM-PRINC X S)) ((CHARACTER? X) (STREAM-PRINC X S)) ((NUMBER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S))) X))))) (~G1667 (DEFAULT-STREAM ~G173))))) (~G1666 STR)))))
  (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 ((~G1669 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1669 (CL:MOD X 1))))))
  (CL:DEFUN FRACTION-CHARS (X) (CL:BLOCK FRACTION-CHARS (CL:BLOCK NIL (FRACTION-CHARS-0 (CL:MOD (ABS X) 1)))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (-  X)) (T X)))))
  (CL:DEFUN - (CL:&REST X) (CL:APPLY #'NUMBER- X))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1670 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1670 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN NUMBER-DIGIT (X) (CL:BLOCK NUMBER-DIGIT (CL:BLOCK NIL (CODE-CHAR (+  X #\0)))))
  (CL:DEFUN INTEGER-CHARS (X) (CL:BLOCK INTEGER-CHARS (CL:BLOCK NIL (REVERSE (INTEGER-CHARS-0 (INTEGER (ABS X)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1671 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10  X) (INTEGER-CHARS-0 (/ (-  X !) 10))))))) (~G1671 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FORMAT-INFO-STREAM (ARR) (CL:BLOCK FORMAT-INFO-STREAM (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1672 (~G163) (CL:COND ((EQ ~G163 NIL) (MAKE-STRING-STREAM)) ((EQ ~G163 T) *STANDARD-OUTPUT*) (T X)))) (~G1672 X)))))
  (CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE 'HANDLE :FUN-IN (CL:LAMBDA (STR) (CL:LABELS ((~G1673 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1673 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR)  X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR)))) :LAST-CHAR 'LAST-CHAR :PEEKED-CHAR 'PEEKED-CHAR :INPUT-LOCATION 'INPUT-LOCATION :OUTPUT-LOCATION 'OUTPUT-LOCATION :USER-DETAIL (MAKE-QUEUE)))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1674 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1674 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1675 (~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)) (~G1675 (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 NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1676 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1676 (CL:CAR LSTS)))))))))
  (CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1677 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G156 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G156 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? 'TRACK? :ID 'ID :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE)) (T INPUT-LOCATION)) ~G156 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL :ID 'ID :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE)) (T OUTPUT-LOCATION)) ~G156 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G156 10)) ~G156)) (~G1677 (MAKE-ARRAY 11))))))
  (CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1678 (~G155) (CL:PROGN (=-AREF 'STRUCT ~G155 0) (=-AREF 'STREAM-LOCATION ~G155 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G155 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G155 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G155 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G155 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G155 6)) ~G155)) (~G1678 (MAKE-ARRAY 7))))))
  (CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G1679 (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 ((~G1680 (!) (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 _)))) (~G1680 (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))))) (~G1679 NIL)))))
  (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) 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 (CL:COND ((EQ (CL:CAR X) 'CL:QUOTE) X) (T (%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:SETQ *CURRENT-MACRO* (CL:CAR X)) (CL:LABELS ((~G1681 (X) (CL:SETQ *CURRENT-MACRO* NIL) X)) (~G1681 (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:&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 :APPLY-VALUES? T :CONCATENATE-SUBLISTS? T :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1682 (~G180) (CL:COND (~G180 ~G180) (T (%KEY? X))))) (~G1682 (%REST-OR-%BODY? X))))))
  (CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1683 (~G179) (CL:COND (~G179 ~G179) (T (%BODY? X))))) (~G1683 (%REST? X))))))
  (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 ((~G1684 (~G130) (CL:LABELS ((~G1685 (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))))) (~G1685 NIL)))) (~G1684 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 ((~G1686 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :TRACK? 'TRACK? :ID PATH :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE) :OUTPUT-LOCATION (MAKE-STREAM-LOCATION :TRACK? 'TRACK? :ID 'ID :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE))) (T (ERROR "Couldn't open file `~A'."  PATH))))) (~G1686 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION :TRACK? 'TRACK? :ID 'ID :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION :TRACK? 'TRACK? :ID 'ID :LINE 'LINE :COLUMN 'COLUMN :TABSIZE 'TABSIZE))) (CL:BLOCK MAKE-STREAM-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :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 _)))) :LAST-CHAR 'LAST-CHAR :PEEKED-CHAR 'PEEKED-CHAR :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :USER-DETAIL 'USER-DETAIL))))
  (CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1687 (~G164) (CL:COND ((EQUAL ~G164 'INPUT) "r") ((EQUAL ~G164 'OUTPUT) "w") ((EQUAL ~G164 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified." ))))) (~G1687 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 ((~G1688 (~G122) (CL:COND (~G122 ~G122) (T (CL:LABELS ((~G1689 (~G123) (CL:COND (~G123 ~G123) (T (STRING? _))))) (~G1689 (NUMBER? _))))))) (~G1688 (CONS? _))))))) (CL:COND (X (CL:PROGN (CL:COND ((LABEL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1690 (~G125) (CL:LABELS ((~G1691 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1691 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1690 X)) (CL:LABELS ((~G1692 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1692 *DEFAULT-LISTPROP*)))) (T X)))))))))
  (CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1693 (SL) (CL:LABELS ((~G1694 (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) 99999))) NIL))))))) (~G1694 (DOT-POSITION SL))))) (~G1693 (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 ((~G1695 (~G62) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G62)))) (~G1695 START)))) (CL:LABELS ((~G1696 (~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))))) (~G1696 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 ((~G1697 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END  !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1698 (L) (CL:LABELS ((~G1699 (S) (CL:LABELS ((~G1700 (~G60) (CL:COND ((INTEGER< ~G60 0) (ERROR "Negative number of iterations: ~A."  ~G60))) (CL:BLOCK NIL (CL:LABELS ((~G1701 (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)))) (~G1701 0))))) (~G1700 (INTEGER L))))) (~G1699 (FUNCALL MAKER  L))))) (~G1698 (-  END START)))))))) (~G1697 (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 ((~G1702 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END  SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1703 (L) (CL:LABELS ((~G1704 (S) (CL:LABELS ((~G1705 (~G57) (CL:COND ((INTEGER< ~G57 0) (ERROR "Negative number of iterations: ~A."  ~G57))) (CL:BLOCK NIL (CL:LABELS ((~G1706 (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)))) (~G1706 0))))) (~G1705 (INTEGER L))))) (~G1704 (CL:MAKE-STRING 0))))) (~G1703 (-  END START)))))))) (~G1702 (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 ((~G1707 (~G59) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G59)))) (~G1707 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 ((~G1708 (~G110) (CL:LABELS ((~G1709 (~G111) (CL:COND ((NOT (EQ (CL:CAR ~G110) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G110)))) (CL:LABELS ((~G1710 (NUM-CDRS) (CL:LABELS ((~G1711 (~G112) (CL:LABELS ((~G1712 (WITHOUT-START) (CL:LABELS ((~G1713 (~G115) (CL:LABELS ((~G1714 (~G116) (CL:COND ((NOT (EQ (CL:CAR ~G115) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G115)))) (CL:LABELS ((~G1715 (NUM-CARS) (CL:LABELS ((~G1716 (~G117) (CL:LABELS ((~G1717 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1717 (CL:CAR ~G117))))) (~G1716 (CL:LABELS ((~G1718 (~G119) (CL:COND (~G119 ~G119) (T (%ERROR "Not enough VALUES."))))) (~G1718 (CL:CDR ~G116))))))) (~G1715 (CL:CAR ~G116))))) (~G1714 (CL:CDR ~G115))))) (~G1713 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START 0))))) (~G1712 (CL:CAR ~G112))))) (~G1711 (CL:LABELS ((~G1719 (~G114) (CL:COND (~G114 ~G114) (T (%ERROR "Not enough VALUES."))))) (~G1719 (CL:CDR ~G111))))))) (~G1710 (CL:CAR ~G111))))) (~G1709 (CL:CDR ~G110))))) (~G1708 (DOT-EXPAND-HEAD-LENGTH X 0))))))
  (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 ((~G1720 (SL) (CL:LABELS ((~G1721 (~G121) (CL:COND (~G121 ~G121) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1721 (== #\. (CL:CAR SL)))))) (~G1720 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1722 (SL) (CL:LABELS ((~G1723 (L) (CL:LABELS ((~G1724 (P) (CL:LABELS ((~G1725 (~G120) (CL:COND (~G120 ~G120) (T (NOT P))))) (~G1725 (== 1 L))))) (~G1724 (DOT-POSITION SL))))) (~G1723 (CL:LENGTH SL))))) (~G1722 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :START NIL :END NIL :FROM-END NIL :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 ((~G1726 (!) (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) !)) (~G1726 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 ((~G1727 (~G308) (CL:LABELS ((~G1728 (~G309) (CL:COND ((NOT (EQ (CL:CAR ~G308) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G308)))) (CL:LABELS ((~G1729 (TOKEN) (CL:LABELS ((~G1730 (~G310) (CL:LABELS ((~G1731 (PKG) (CL:LABELS ((~G1732 (~G311) (CL:LABELS ((~G1733 (SYM) (CL:LABELS ((~G1734 (~G307) (CL:COND ((EQ ~G307 NIL) NIL) ((EQ ~G307 'EOF) NIL) ((EQ ~G307 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G307 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G307 '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))))))) (~G1734 TOKEN)))) (~G1733 (CL:CAR ~G311))))) (~G1732 (CL:LABELS ((~G1735 (~G314) (CL:COND (~G314 ~G314) (T (%ERROR "Not enough VALUES."))))) (~G1735 (CL:CDR ~G310))))))) (~G1731 (CL:CAR ~G310))))) (~G1730 (CL:LABELS ((~G1736 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1736 (CL:CDR ~G309))))))) (~G1729 (CL:CAR ~G309))))) (~G1728 (CL:CDR ~G308))))) (~G1727 (READ-TOKEN STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1737 (~G270) (CL:COND ((EQ ~G270 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G270 'CHAR) (READ-CHAR STR)) ((EQ ~G270 'NUMBER) (CL:LABELS ((~G1738 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1738 (MAKE-STRING-STREAM)))) ((EQ ~G270 'HEXNUM) (READ-HEX STR)) ((EQ ~G270 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G270 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing."  (CL:LABELS ((~G1739 (~G269) (CL:COND ((EQUAL ~G269 'BRACKET-CLOSE) "Round") ((EQUAL ~G269 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G269 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1739 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A."  TOKEN SYM))))))) (~G1737 TOKEN)))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1740 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G1741 (~G243) (CL:COND (~G243 ~G243) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1741 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1740 (EQ X 'BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1742 (!) (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)))))))))) (~G1742 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM :TEST #'EQL :INCLUDE? NIL)))))))
  (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 ((~G1743 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !) 99999) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1743 (POSITION OBJ SEQ :START NIL :END NIL :FROM-END NIL :TEST TEST))))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1744 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+  (* V 16) (-  ! (CL:COND ((DIGIT-CHAR? ! :BASE 10) #\0) (T (-  #\A 10)))))))) (T V)))) (~G1744 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1745 (~G228) (CL:COND (~G228 ~G228) (T (ERROR "Illegal character '~A' at begin of hexadecimal number."  (PEEK-CHAR STR)))))) (~G1745 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1746 (~G229) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number."  (PEEK-CHAR STR)))) ~G229)) (~G1746 (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 ((~G1747 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G1748 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1749 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1750 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1751 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G1752 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1753 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G1754 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1755 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1756 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1757 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G1758 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1759 (~G256) (CL:COND (~G256 ~G256) (T (== X #\^))))) (~G1759 (== X #\#))))))) (~G1758 (== X #\"))))))) (~G1757 (== X #\;))))))) (~G1756 (== X #\:))))))) (~G1755 (== X #\,))))))) (~G1754 (== X #\`))))))) (~G1753 (== X #\'))))))) (~G1752 (== X #\}))))))) (~G1751 (== X #\{))))))) (~G1750 (== X #\]))))))) (~G1749 (== X #\[))))))) (~G1748 (== X #\)))))))) (~G1747 (== X #\())))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1760 (~G81) (CL:COND (~G81 ~G81) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1760 (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 ((~G1761 (~G80) (CL:COND (~G80 ~G80) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1761 (%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 ((~G1762 (~G82) (CL:COND (~G82 ~G82) (T (CL:LABELS ((~G1763 (~G83) (CL:COND (~G83 ~G83) (T (CL:COND ((>= X  #\a) (<= X  #\f))))))) (~G1763 (CL:COND ((>= X  #\A) (<= X  #\F))))))))) (~G1762 (DIGIT-CHAR? X :BASE 10))))))
  (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 ((~G1764 (~G230) (CL:COND (~G230 ~G230) (T 0)))) (~G1764 (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 ((~G1765 (!) (CL:COND (! (DIGIT-CHAR? ! :BASE 10))))) (~G1765 (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 ((~G1766 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? ! :BASE 10) !))))))) (~G1766 (PEEK-CHAR STR))))))
  (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G1767 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1767 (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 ((~G1768 (~G226) (CL:COND (~G226 ~G226) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR)  STR) STR)))))) (~G1768 (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 ((~G1769 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1769 (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 ((~G1770 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1770 (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 ((~G1771 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G1772 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G1773 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G1774 (~G241) (CL:COND (~G241 ~G241) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1774 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1773 (EQ X 'QUASIQUOTE))))))) (~G1772 (EQ X 'BACKQUOTE))))))) (~G1771 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1775 (~G298) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1776 (~G304) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G298)) ~G304)) (~G1776 (CL:PROGN (CL:LABELS ((~G1777 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1778 (~G299) (CL:LABELS ((~G1779 (~G300) (CL:COND ((NOT (EQ (CL:CAR ~G299) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G299)))) (CL:LABELS ((~G1780 (TOKEN) (CL:LABELS ((~G1781 (~G301) (CL:LABELS ((~G1782 (PKG) (CL:LABELS ((~G1783 (~G302) (CL:LABELS ((~G1784 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1784 (CL:CAR ~G302))))) (~G1783 (CL:LABELS ((~G1785 (~G306) (CL:COND (~G306 ~G306) (T (%ERROR "Not enough VALUES."))))) (~G1785 (CL:CDR ~G301))))))) (~G1782 (CL:CAR ~G301))))) (~G1781 (CL:LABELS ((~G1786 (~G305) (CL:COND (~G305 ~G305) (T (%ERROR "Not enough VALUES."))))) (~G1786 (CL:CDR ~G300))))))) (~G1780 (CL:CAR ~G300))))) (~G1779 (CL:CDR ~G299))))) (~G1778 (READ-TOKEN STR))))) (T !)))) (~G1777 (READ-CONS STR)))))))) (~G1775 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1787 (LOC) (CL:LABELS ((~G1788 (LINE) (CL:LABELS ((~G1789 (COLUMN) (CL:LABELS ((~G1790 (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 ((~G1791 (~G272) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1792 (~G275) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G272)) ~G275)) (~G1792 (CL:PROGN (CL:LABELS ((~G1793 (~G271) (CL:COND ((EQ ~G271 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G271 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G271 '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))))))) (~G1793 TOKEN))))))) (~G1791 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1794 (~G274) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1795 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G274)) ~G281)) (~G1795 (CL:PROGN (CL:LABELS ((~G1796 (!) (CL:COND (! (CL:LABELS ((~G1797 (~G276) (CL:LABELS ((~G1798 (~G277) (CL:COND ((NOT (EQ (CL:CAR ~G276) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G276)))) (CL:LABELS ((~G1799 (TOKEN) (CL:LABELS ((~G1800 (~G278) (CL:LABELS ((~G1801 (PKG) (CL:LABELS ((~G1802 (~G279) (CL:LABELS ((~G1803 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1804 (X) (CL:LABELS ((~G1805 (~G284) (CL:LABELS ((~G1806 (~G285) (CL:COND ((NOT (EQ (CL:CAR ~G284) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G284)))) (CL:LABELS ((~G1807 (TOKEN) (CL:LABELS ((~G1808 (~G286) (CL:LABELS ((~G1809 (PKG) (CL:LABELS ((~G1810 (~G287) (CL:LABELS ((~G1811 (SYM) (CL:LABELS ((~G1812 (~G273) (CL:COND (~G273 ~G273) (T (ERR "Only one value allowed after dotted cons."))))) (~G1812 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1811 (CL:CAR ~G287))))) (~G1810 (CL:LABELS ((~G1813 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1813 (CL:CDR ~G286))))))) (~G1809 (CL:CAR ~G286))))) (~G1808 (CL:LABELS ((~G1814 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1814 (CL:CDR ~G285))))))) (~G1807 (CL:CAR ~G285))))) (~G1806 (CL:CDR ~G284))))) (~G1805 (READ-TOKEN STR))))) (~G1804 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1803 (CL:CAR ~G279))))) (~G1802 (CL:LABELS ((~G1815 (~G283) (CL:COND (~G283 ~G283) (T (%ERROR "Not enough VALUES."))))) (~G1815 (CL:CDR ~G278))))))) (~G1801 (CL:CAR ~G278))))) (~G1800 (CL:LABELS ((~G1816 (~G282) (CL:COND (~G282 ~G282) (T (%ERROR "Not enough VALUES."))))) (~G1816 (CL:CDR ~G277))))))) (~G1799 (CL:CAR ~G277))))) (~G1798 (CL:CDR ~G276))))) (~G1797 !))) (T (ERR "Closing bracket missing."))))) (~G1796 (READ-TOKEN STR)))))))) (~G1794 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1817 (~G291) (CL:LABELS ((~G1818 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G291)))) (CL:LABELS ((~G1819 (TOKEN) (CL:LABELS ((~G1820 (~G293) (CL:LABELS ((~G1821 (PKG) (CL:LABELS ((~G1822 (~G294) (CL:LABELS ((~G1823 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1823 (CL:CAR ~G294))))) (~G1822 (CL:LABELS ((~G1824 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1824 (CL:CDR ~G293))))))) (~G1821 (CL:CAR ~G293))))) (~G1820 (CL:LABELS ((~G1825 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1825 (CL:CDR ~G292))))))) (~G1819 (CL:CAR ~G292))))) (~G1818 (CL:CDR ~G291))))) (~G1817 (READ-TOKEN STR)))))) (~G1790 (STREAM-LOCATION-ID LOC))))) (~G1789 (STREAM-LOCATION-COLUMN LOC))))) (~G1788 (STREAM-LOCATION-LINE LOC))))) (~G1787 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1826 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1826 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1827 (~G225) (CL:COND (~G225 ~G225) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1827 (HREF *MEMORIZED-NUMBERS* X))))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1828 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1829 (~G264) (CL:LABELS ((~G1830 (~G265) (CL:COND ((NOT (EQ (CL:CAR ~G264) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A."  ~G264)))) (CL:LABELS ((~G1831 (PKG) (CL:LABELS ((~G1832 (~G266) (CL:LABELS ((~G1833 (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 ((~G1834 (~G263) (CL:COND ((CHARACTER== ~G263 #\() 'BRACKET-OPEN) ((CHARACTER== ~G263 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G263 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G263 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G263 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G263 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G263 #\') 'CL:QUOTE) ((CHARACTER== ~G263 #\`) 'BACKQUOTE) ((CHARACTER== ~G263 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G263 #\") 'DBLQUOTE) ((CHARACTER== ~G263 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G263 #\#) (CL:LABELS ((~G1835 (~G262) (CL:COND ((CHARACTER== ~G262 #\\) 'CHAR) ((CHARACTER== ~G262 #\x) 'HEXNUM) ((CHARACTER== ~G262 #\') 'CL:FUNCTION) ((CHARACTER== ~G262 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'." ))))) (~G1835 (READ-CHAR STR)))) ((CHARACTER== ~G263 -1) 'EOF)))) (~G1834 (READ-CHAR STR))))))) PKG SYM))) (~G1833 (CL:CAR ~G266))))) (~G1832 (CL:LABELS ((~G1836 (~G268) (CL:COND (~G268 ~G268) (T (%ERROR "Not enough VALUES."))))) (~G1836 (CL:CDR ~G265))))))) (~G1831 (CL:CAR ~G265))))) (~G1830 (CL:CDR ~G264))))) (~G1829 !))))))) (~G1828 (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 ~G258 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G258)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1837 (~G260) (CL:COND (~G260 ~G260) (T (DIGIT-CHAR? (CL:CAR X) :BASE 10))))) (~G1837 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1838 (~G259) (CL:COND (~G259 ~G259) (T (== #\. (CL:CAR X)))))) (~G1838 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1839 (~G261) (CL:COND (~G261 ~G261) (T (== #\. _))))) (~G1839 (DIGIT-CHAR? _ :BASE 10)))))  (CL:CDR X))) (T T)))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1840 (~G108) (CL:LABELS ((~G1841 (SEQ) (CL:TAGBODY ~G106 (CL:COND ((NOT ~G108) (CL:GO ~G107))) (CL:SETQ SEQ (CL:CAR ~G108)) (CL:LABELS ((~G1842 (~G105) (CL:COND ((INTEGER< ~G105 0) (ERROR "Negative number of iterations: ~A."  ~G105))) (CL:BLOCK NIL (CL:LABELS ((~G1843 (!) (CL:TAGBODY ~G109 (CL:COND ((INTEGER== ! ~G105) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1844 (~G104) (CL:COND (~G104 ~G104) (T (CL:RETURN-FROM EVERY NIL))))) (~G1844 (FUNCALL PRED  (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G109)))) (~G1843 0))))) (~G1842 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G108 (CL:CDR ~G108)) (CL:GO ~G106) ~G107 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1841 NIL)))) (~G1840 SEQS))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1845 (SYM) (CL:LABELS ((~G1846 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES  (CL:LABELS ((~G1847 (~G257) (CL:COND (~G257 ~G257) (T T)))) (~G1847 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES  NIL SYM)))))))) (~G1846 (PEEK-CHAR STR))))) (~G1845 (GET-SYMBOL STR))))))
  (CL:DEFUN GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1848 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1848 (PEEK-CHAR STR))))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1849 (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)))))))) (~G1849 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1850 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1850 (READ-CHAR STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1851 (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))))))))) (~G1851 (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 ((~G1852 (~G227) (CL:COND (~G227 ~G227) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1852 (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 ((~G1853 (~G327) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1854 (~G328) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G327)) ~G328)) (~G1854 (CL:PROGN (FRESH-LINE *STANDARD-OUTPUT*) (%ERROR (CL:APPLY #'FORMAT NIL MSG ARGS))))))) (~G1853 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G901 (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 ((~G1855 (~G899) (CL:COND ((CL:ATOM ~G899) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G899) (QQ _)) ((QUASIQUOTE-SPLICE? ~G899) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1855 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1856 (~G900) (CL:COND ((QUOTE? ~G900) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G900) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1856 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING #'DISP :DONT-ASCEND-IF NIL :DONT-ASCEND-AFTER-IF NIL))))) (CL:COND ((NOT (DUMP-PASS? 'QUOTE-EXPAND)) (CL:PROGN (CL:RETURN-FROM NIL (~G901 X))))) (FRESH-LINE *STANDARD-OUTPUT*) (FORMAT T "; **** QUOTE-EXPAND~%" ) (CL:LABELS ((~G1857 (~G902) (FRESH-LINE *STANDARD-OUTPUT*) (FORMAT T "; **** end of QUOTE-EXPAND~%" ) ~G902)) (~G1857 (CL:LABELS ((~G1858 (~G903) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* X)) (CL:LABELS ((~G1859 (~G905) (CL:PROGN (CL:SETQ *CURRENT-PASS-INPUT* ~G903)) ~G905)) (~G1859 (CL:PROGN (CL:LABELS ((~G1860 (~G904) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* T)) (CL:LABELS ((~G1861 (~G906) (CL:PROGN (CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* ~G904)) ~G906)) (~G1861 (CL:PROGN (LATE-PRINT (~G901 X) *STANDARD-OUTPUT* :PRINT-INFO (MAKE-PRINT-INFO :PRETTY-PRINT? 'PRETTY-PRINT? :DOWNCASE? 'DOWNCASE? :INDENTATION 'INDENTATION))))))) (~G1860 *ALWAYS-PRINT-PACKAGE-NAMES?*))))))) (~G1858 *CURRENT-PASS-INPUT*))))))))
  (CL:DEFUN DUMP-PASS? (NAME) (CL:BLOCK DUMP-PASS? (CL:BLOCK NIL (CL:COND (*TRANSPILER* (CL:LABELS ((~G1862 (!) (CL:COND (! (CL:LABELS ((~G1863 (~G434) (CL:COND (~G434 ~G434) (T (MEMBER NAME (ENSURE-LIST !) :TEST #'EQL))))) (~G1863 (EQ T !))))))) (~G1862 (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 ((~G1864 (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)))) (~G1864 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 ((~G1865 (Y) (CL:LABELS ((~G1866 (A) (CL:PROGN (CL:LABELS ((~G1867 (~G366) (CL:LABELS ((~G1868 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1868 (CL:COND ((CONS? ~G366) (CPR ~G366))))))) (~G1867 I)) (CL:LABELS ((~G1869 (~G365) (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)) ~G365))) (~G1869 *DEFAULT-LISTPROP*))))) (~G1866 (CL:LABELS ((~G1870 (~G364) (CL:COND (~G364 ~G364) (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))))))) (~G1870 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF  Y) Y)))))))))) (~G1865 (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 ((~G1871 (~G425) (CL:COND (~G425 ~G425) (T (CL:LABELS ((~G1872 (~G426) (CL:COND (~G426 ~G426) (T (CL:LABELS ((~G1873 (~G427) (CL:COND (~G427 ~G427) (T (CL:LABELS ((~G1874 (~G428) (CL:COND (~G428 ~G428) (T (CL:LABELS ((~G1875 (~G429) (CL:COND (~G429 ~G429) (T (HASH-TABLE? X))))) (~G1875 (ARRAY? X))))))) (~G1874 (STRING? X))))))) (~G1873 (NUMBER? X))))))) (~G1872 (EQ T X))))))) (~G1871 (NOT X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1876 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1876 (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 ((~G1877 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1877 (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 ((~G1878 (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)))))))) (~G1878 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFVAR *GENSYM-PREFIX*)
  
negative.code: (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 ((~G1480 (!) (CL:LABELS ((~G1481 (L) (CL:LABELS ((~G1482 (~G1426) (CL:COND ((INTEGER< ~G1426 0) (ERROR "Negative number of iterations: ~A."  ~G1426))) (CL:BLOCK NIL (CL:LABELS ((~G1483 (I) (CL:TAGBODY ~G1427 (CL:COND ((INTEGER== I ~G1426) (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 ~G1427)))) (~G1483 0))))) (~G1482 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1481 NIL)))) (~G1480 (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 ((~G1484 (!) (CL:LABELS ((~G1485 (~G1428) (CL:COND ((INTEGER< ~G1428 0) (ERROR "Negative number of iterations: ~A."  ~G1428))) (CL:BLOCK NIL (CL:LABELS ((~G1486 (N) (CL:TAGBODY ~G1429 (CL:COND ((INTEGER== N ~G1428) (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 ~G1429)))) (~G1486 0))))) (~G1485 (INTEGER BITS))))) (~G1484 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1487 (!) (CL:LABELS ((~G1488 (~G1430) (CL:COND ((INTEGER< ~G1430 0) (ERROR "Negative number of iterations: ~A."  ~G1430))) (CL:BLOCK NIL (CL:LABELS ((~G1489 (N) (CL:TAGBODY ~G1431 (CL:COND ((INTEGER== N ~G1430) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1431)))) (~G1489 0))))) (~G1488 (INTEGER BITS))))) (~G1487 (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 ((~G1490 (~G1435) (CL:LABELS ((~G1491 (I) (CL:TAGBODY ~G1433 (CL:COND ((NOT ~G1435) (CL:GO ~G1434))) (CL:SETQ I (CL:CAR ~G1435)) (CL:LABELS ((~G1492 (~G1432) (CL:COND (~G1432 ~G1432) (T (CL:RETURN-FROM NIL NIL))))) (~G1492 (FUNCALL PREDICATE  (CL:CAR X) I))) (CL:SETQ ~G1435 (CL:CDR ~G1435)) (CL:GO ~G1433) ~G1434 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1491 NIL)))) (~G1490 (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))
  