anchor.diff:  (CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST (CL:FUNCTION CL:EQ)))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-SOURCE)))
   (CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (ERROR "Can't set function source in the Common Lisp core.")) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION =-FUNCTION-SOURCE)))
   (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-BYTECODE)))
  -(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G1324 (~G1274) (CL:COND (~G1274 ~G1274) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G1324 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
  +(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G1326 (~G1274) (CL:COND (~G1274 ~G1274) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G1326 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
   (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) (CL:FUNCTION HASH-TABLE?)))
   (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) (CL:FUNCTION HREF)))
   (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) (CL:FUNCTION =-HREF)))
   (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) (CL:FUNCTION HREMOVE)))
  -(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1325 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1325 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
  -(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1326 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1326 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1327 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1327 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
  +(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1328 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1328 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
   (CL:PROGN (CL:DEFUN SYS-IMAGE-CREATE (PATHNAME FUN) (SB-EXT:SAVE-LISP-AND-DIE PATHNAME :TOPLEVEL (CL:LAMBDA NIL (CL:FUNCALL FUN)))) (CL:SETF (CL:GETHASH 'SYS-IMAGE-CREATE *BUILTIN-ATOMS*) (CL:FUNCTION SYS-IMAGE-CREATE)))
  -(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1327 (~G1276) (CL:COND (~G1276 ~G1276) (T NIL)))) (~G1327 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
  +(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1329 (~G1276) (CL:COND (~G1276 ~G1276) (T NIL)))) (~G1329 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
   (CL:DEFVAR *DEFAULT-LISTPROP*)
   (CL:PROGN (CL:DEFUN CPR (X) X NIL) (CL:SETF (CL:GETHASH 'CPR *BUILTIN-ATOMS*) (CL:FUNCTION CPR)))
   (CL:PROGN (CL:DEFUN RPLACP (V X) X V) (CL:SETF (CL:GETHASH 'RPLACP *BUILTIN-ATOMS*) (CL:FUNCTION RPLACP)))
   (CL:PROGN (CL:DEFUN FILTER (FUN X) (CL:MAPCAR FUN X)) (CL:SETF (CL:GETHASH 'FILTER *BUILTIN-ATOMS*) (CL:FUNCTION FILTER)))
   (CL:PROGN (CL:DEFUN APPEND (CL:&REST X) X (CL:APPLY (CL:FUNCTION CL:NCONC) (CL:MAPCAR (CL:FUNCTION CL:COPY-LIST) X))) (CL:SETF (CL:GETHASH 'APPEND *BUILTIN-ATOMS*) (CL:FUNCTION APPEND)))
   (CL:DEFUN %LOAD-R (S) (CL:COND ((PEEK-CHAR S) (CL:PROGN (CL:CONS (READ S) (%LOAD-R S))))))
  -(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G1328 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1328 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  -(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1329 (~G1280) (CL:LABELS ((~G1330 (I) (CL:TAGBODY ~G1278 (CL:COND ((NOT ~G1280) (CL:GO ~G1279))) (CL:SETQ I (CL:CAR ~G1280)) (EVAL (%EXPAND I)) (CL:SETQ ~G1280 (CL:CDR ~G1280)) (CL:GO ~G1278) ~G1279 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1330 NIL)))) (~G1329 (CL:LABELS ((~G1331 (S) (CL:LABELS ((~G1332 (~G1277) (CLOSE S) ~G1277)) (~G1332 (CL:BLOCK NIL (%LOAD-R S)))))) (~G1331 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
  +(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G1330 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1330 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  +(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1331 (~G1280) (CL:LABELS ((~G1332 (I) (CL:TAGBODY ~G1278 (CL:COND ((NOT ~G1280) (CL:GO ~G1279))) (CL:SETQ I (CL:CAR ~G1280)) (EVAL (%EXPAND I)) (CL:SETQ ~G1280 (CL:CDR ~G1280)) (CL:GO ~G1278) ~G1279 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1332 NIL)))) (~G1331 (CL:LABELS ((~G1333 (S) (CL:LABELS ((~G1334 (~G1277) (CLOSE S) ~G1277)) (~G1334 (CL:BLOCK NIL (%LOAD-R S)))))) (~G1333 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
   (CL:DEFUN ENV-MACROS NIL (SYMBOL-VALUE (TRE-SYMBOL '*MACROS*)))
   (CL:PROGN (CL:DEFUN MACRO? (X) (CL:RASSOC X (ENV-MACROS) :TEST (CL:FUNCTION EQ))) (CL:SETF (CL:GETHASH 'MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION MACRO?)))
  -(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G1333 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G1333 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
  -(CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G1334 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G1334 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  +(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G1335 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G1335 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
  +(CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G1336 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G1336 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
   (CL:DEFVAR *MACROEXPAND*)
  -(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G1335 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1335 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
  +(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G1337 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1337 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
   (CL:PROGN (CL:DEFUN MACROEXPAND (X) (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (MACROEXPAND X))))) (F X (MACROEXPAND-1 X)))) (CL:SETF (CL:GETHASH 'MACROEXPAND *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND)))
   (CL:PROGN (CL:DEFUN QUIT (CL:&OPTIONAL EXIT-CODE) (SB-EXT:QUIT :UNIX-STATUS EXIT-CODE)) (CL:SETF (CL:GETHASH 'QUIT *BUILTIN-ATOMS*) (CL:FUNCTION QUIT)))
   (CL:PROGN (CL:DEFUN NANOTIME NIL 0) (CL:SETF (CL:GETHASH 'NANOTIME *BUILTIN-ATOMS*) (CL:FUNCTION NANOTIME)))
  -(CL:PROGN (CL:DEFUN NUMBER? (X) (CL:LABELS ((~G1336 (~G1281) (CL:COND (~G1281 ~G1281) (T (CL:CHARACTERP X))))) (~G1336 (CL:NUMBERP X)))) (CL:SETF (CL:GETHASH 'NUMBER? *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER?)))
  +(CL:PROGN (CL:DEFUN NUMBER? (X) (CL:LABELS ((~G1338 (~G1281) (CL:COND (~G1281 ~G1281) (T (CL:CHARACTERP X))))) (~G1338 (CL:NUMBERP X)))) (CL:SETF (CL:GETHASH 'NUMBER? *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER?)))
   (CL:PROGN (CL:DEFUN INTEGER (X) (CL:FLOOR X)) (CL:SETF (CL:GETHASH 'INTEGER *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER)))
   (CL:DEFUN CHARS-TO-NUMBERS (X) (CL:MAPCAR (CL:LAMBDA (X) (CL:COND ((CL:CHARACTERP X) (CL:CHAR-CODE X)) (T X))) X))
   (CL:PROGN (CL:DEFUN CODE-CHAR (X) (CL:COND ((CL:CHARACTERP X) X) (T (CL:CODE-CHAR (CL:FLOOR X))))) (CL:SETF (CL:GETHASH 'CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CODE-CHAR)))
  
positive.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 ((~G1355 (TESTS) (CL:LABELS ((~G1356 (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)))) (~G1356 (CL:CAR (CL:LAST TESTS)))))) (~G1355 (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) ((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 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 ((~G1357 (~G131) (CL:LABELS ((~G1358 (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))))) (~G1358 NIL)))) (~G1357 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 ((~G1359 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1359 (%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 ((~G1360 (~G125) (CL:LABELS ((~G1361 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1361 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1360 X)) (CL:LABELS ((~G1362 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1362 *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 ((~G1363 (~G234) (CL:COND (~G234 ~G234) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1363 (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 ((~G1364 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1365 (~G335) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G334)) ~G335)) (~G1365 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1364 *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 ((~G1366 (~G735) (CL:COND ((CL:ATOM ~G735) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G735) (QQ _)) ((QUASIQUOTE-SPLICE? ~G735) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1366 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1367 (~G736) (CL:COND ((QUOTE? ~G736) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G736) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1367 _))))) (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 ((~G1368 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1368 (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 ((~G1369 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1369 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1370 (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)))))))) (~G1370 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-PREFIX*)
  (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
  (CL:DEFVAR *STANDARD-INPUT*)
  (CL:DEFVAR *DEFINITION-PRINTER*)
  (CL:DEFVAR *MACROCALL*)
  (CL:DEFVAR *MACRO?*)
  (CL:DEFVAR +CL-FUNCTION-IMPORTS+)
  (CL:DEFUN MAKE-STANDARD-STREAM NIL (CL:BLOCK MAKE-STANDARD-STREAM (CL:BLOCK NIL (MAKE-STREAM :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR NIL))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C NIL)) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF NIL)))))))
  (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
  (CL:DEFUN MAPCAN (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAN (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION NCONC) (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC LISTS)))))
  (CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1371 (L) (CL:LABELS ((~G1372 (S) (CL:BLOCK NIL (CL:LABELS ((~G1373 (I) (CL:TAGBODY ~G94 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G94)))) (~G1373 (-- L)))) S)) (~G1372 NIL)))) (~G1371 (CL:LENGTH X))))))
  (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 ((~G1374 (Y) (CL:LABELS ((~G1375 (A) (CL:PROGN (CL:LABELS ((~G1376 (~G734) (CL:LABELS ((~G1377 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1377 (CL:COND ((CONS? ~G734) (CPR ~G734))))))) (~G1376 I)) (CL:LABELS ((~G1378 (~G733) (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)) ~G733))) (~G1378 *DEFAULT-LISTPROP*))))) (~G1375 (CL:LABELS ((~G1379 (~G732) (CL:COND (~G732 ~G732) (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))))))) (~G1379 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1374 (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 ((~G1380 (~G432) (CL:COND (~G432 ~G432) (T (CL:LABELS ((~G1381 (~G433) (CL:COND (~G433 ~G433) (T (CL:LABELS ((~G1382 (~G434) (CL:COND (~G434 ~G434) (T (CL:LABELS ((~G1383 (~G435) (CL:COND (~G435 ~G435) (T (CL:LABELS ((~G1384 (~G436) (CL:COND (~G436 ~G436) (T (HASH-TABLE? X))))) (~G1384 (ARRAY? X))))))) (~G1383 (STRING? X))))))) (~G1382 (NUMBER? X))))))) (~G1381 (EQ T X))))))) (~G1380 (NOT X))))))
  (CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1385 (~G179) (CL:LABELS ((~G1386 (S) (CL:LABELS ((~G1387 (~G180) (CL:COND (~G179 ~G180) (T (GET-STREAM-STRING S))))) (~G1387 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1386 (DEFAULT-STREAM ~G179))))) (~G1385 STR)))))
  (CL:DEFUN =-STREAM-PEEKED-CHAR (VAL ARR) (CL:BLOCK =-STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 7)))))
  (CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1388 (~G233) (CL:COND (~G233 ~G233) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1388 (READ-PEEKED-CHAR STR))))))
  (CL:DEFUN STREAM-PEEKED-CHAR (ARR) (CL:BLOCK STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:AREF ARR 7))))
  (CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1389 (~G315) (CL:LABELS ((~G1390 (~G316) (CL:COND ((NOT (EQ (CL:CAR ~G315) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G315)))) (CL:LABELS ((~G1391 (TOKEN) (CL:LABELS ((~G1392 (~G317) (CL:LABELS ((~G1393 (PKG) (CL:LABELS ((~G1394 (~G318) (CL:LABELS ((~G1395 (SYM) (CL:LABELS ((~G1396 (~G314) (CL:COND ((EQ ~G314 NIL) NIL) ((EQ ~G314 'EOF) NIL) ((EQ ~G314 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G314 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G314 '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))))))) (~G1396 TOKEN)))) (~G1395 (CL:CAR ~G318))))) (~G1394 (CL:LABELS ((~G1397 (~G321) (CL:COND (~G321 ~G321) (T (%ERROR "Not enough VALUES."))))) (~G1397 (CL:CDR ~G317))))))) (~G1393 (CL:CAR ~G317))))) (~G1392 (CL:LABELS ((~G1398 (~G320) (CL:COND (~G320 ~G320) (T (%ERROR "Not enough VALUES."))))) (~G1398 (CL:CDR ~G316))))))) (~G1391 (CL:CAR ~G316))))) (~G1390 (CL:CDR ~G315))))) (~G1389 (READ-TOKEN STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1399 (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))))))))) (~G1399 (PEEK-CHAR STR))))))
  (CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1400 (SL) (CL:LABELS ((~G1401 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1401 (DOT-POSITION SL))))) (~G1400 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
  (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION))) (CL:BLOCK MAKE-STREAM-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR (STREAM-HANDLE _)))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C (STREAM-HANDLE STR))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF (STREAM-HANDLE _))))))))
  (CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1402 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM-LOCATION ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G156 6)) ~G156)) (~G1402 (MAKE-ARRAY 7))))))
  (CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1403 (~G166) (CL:COND ((EQUAL ~G166 'INPUT) "r") ((EQUAL ~G166 'OUTPUT) "w") ((EQUAL ~G166 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1403 DIRECTION)))))
  (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN CDRLIST (~G127) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G127))))
  (CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1404 (~G182) (CL:COND (~G182 ~G182) (T (%KEY? X))))) (~G1404 (%REST-OR-%BODY? X))))))
  (CL:DEFUN %MACROEXPAND-CALL (X) (CL:COND ((CL:APPLY *MACRO?* (CL:LIST X)) (%MACROEXPAND-XLAT X)) (T X)))
  (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1405 (!) (CL:COND ((CL:LABELS ((~G1406 (~G194) (CL:COND (~G194 ~G194) (T (EQ ! 'ERROR))))) (~G1406 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1405 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
  (CL:DEFUN SOLE? (X) (CL:BLOCK SOLE? (CL:BLOCK NIL (== 1 (CL:LENGTH X)))))
  (CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:CONS (COPY-HEAD X SIZE) (GROUP (CL:NTHCDR SIZE X) SIZE)))))))
  
negative.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 ((~G1570 (~G184) (CL:COND (~G184 ~G184) (T (CL:LABELS ((~G1571 (~G185) (CL:COND (~G185 ~G185) (T (CL:LABELS ((~G1572 (~G186) (CL:COND (~G186 ~G186) (T (EQ X 'CL:&KEY))))) (~G1572 (EQ X 'CL:&OPTIONAL))))))) (~G1571 (EQ X 'CL:&BODY))))))) (~G1570 (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 ((~G1573 (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 ((~G1574 (!) (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 _)))) (~G1574 (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))))) (~G1573 NIL)))))
  (CL:DEFVAR *READER-FINDS-SYMBOLS?*)
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1575 (!) (CL:BLOCK NIL (CL:LABELS ((~G1576 (~G41) (CL:LABELS ((~G1577 (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 !))))) (~G1577 NIL)))) (~G1576 LST))))) (~G1575 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1578 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1578 (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 ((~G1579 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1579 (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 ((~G1580 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1580 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1581 (~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)) (~G1581 (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 ((~G1582 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1582 (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 ((~G1583 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1583 (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 ((~G1584 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1584 (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 ((~G1585 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1586 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1586 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1585 (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 ((~G1587 (~G232) (CL:COND (~G232 ~G232) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1587 (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 ((~G1588 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1588 (PEEK-CHAR STR))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1589 (~G110) (CL:LABELS ((~G1590 (SEQ) (CL:TAGBODY ~G108 (CL:COND ((NOT ~G110) (CL:GO ~G109))) (CL:SETQ SEQ (CL:CAR ~G110)) (CL:LABELS ((~G1591 (~G107) (CL:COND ((INTEGER< ~G107 0) (ERROR "Negative number of iterations: ~A." ~G107))) (CL:BLOCK NIL (CL:LABELS ((~G1592 (!) (CL:TAGBODY ~G111 (CL:COND ((INTEGER== ! ~G107) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1593 (~G106) (CL:COND (~G106 ~G106) (T (CL:RETURN-FROM EVERY NIL))))) (~G1593 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G111)))) (~G1592 0))))) (~G1591 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G110 (CL:CDR ~G110)) (CL:GO ~G108) ~G109 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1590 NIL)))) (~G1589 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1594 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1594 (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 ((~G1595 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1595 (%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 ((~G1596 (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)))))))) (~G1596 (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 ((~G1597 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1597 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1598 (~G70) (CL:LABELS ((~G1599 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1600 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1600 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1599 NIL)))) (~G1598 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1601 (~G18) (CL:LABELS ((~G1602 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1603 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1604 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1604 (< N I))))))) (~G1603 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1602 NIL)))) (~G1601 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1605 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1606 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1607 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1608 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G1609 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1610 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G1611 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1612 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1613 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1614 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1615 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1616 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1617 (~G263) (CL:COND (~G263 ~G263) (T (== X #\^))))) (~G1617 (== X #\#))))))) (~G1616 (== X #\"))))))) (~G1615 (== X #\;))))))) (~G1614 (== X #\:))))))) (~G1613 (== X #\,))))))) (~G1612 (== X #\`))))))) (~G1611 (== X #\'))))))) (~G1610 (== X #\}))))))) (~G1609 (== X #\{))))))) (~G1608 (== X #\]))))))) (~G1607 (== X #\[))))))) (~G1606 (== X #\)))))))) (~G1605 (== 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 ((~G1618 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1618 (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 ((~G1619 (E) (CL:LABELS ((~G1620 (S) (CL:COND ((CL:LABELS ((~G1621 (~G103) (CL:COND (~G103 ~G103) (T (CL:COND ((< S E) FROM-END)))))) (~G1621 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1622 (~G104) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G104)))) (~G1622 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1623 (I) (CL:TAGBODY ~G105 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1624 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1624 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G105)))) (~G1623 S))))) (~G1620 (CL:LABELS ((~G1625 (~G102) (CL:COND (~G102 ~G102) (T 0)))) (~G1625 START)))))) (~G1619 (CL:LABELS ((~G1626 (~G101) (CL:COND (~G101 ~G101) (T (-- (CL:LENGTH SEQ)))))) (~G1626 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1627 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1628 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1629 (~G97) (CL:LABELS ((~G1630 (!) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ ! (CL:CAR ~G97)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1630 NIL)))) (~G1629 !))))) (~G1628 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1631 (~G100) (CL:LABELS ((~G1632 (!) (CL:TAGBODY ~G98 (CL:COND ((NOT ~G100) (CL:GO ~G99))) (CL:SETQ ! (CL:CAR ~G100)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G100 (CL:CDR ~G100)) (CL:GO ~G98) ~G99 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1632 NIL)))) (~G1631 !))))))) (~G1627 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1633 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1633 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1634 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1634 (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))))))
  