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: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 ((~G1566 (~G184) (CL:COND (~G184 ~G184) (T (CL:LABELS ((~G1567 (~G185) (CL:COND (~G185 ~G185) (T (CL:LABELS ((~G1568 (~G186) (CL:COND (~G186 ~G186) (T (EQ X 'CL:&KEY))))) (~G1568 (EQ X 'CL:&OPTIONAL))))))) (~G1567 (EQ X 'CL:&BODY))))))) (~G1566 (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 ((~G1569 (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 ((~G1570 (!) (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 _)))) (~G1570 (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))))) (~G1569 NIL)))))
  (CL:DEFVAR *READER-FINDS-SYMBOLS?*)
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1571 (!) (CL:BLOCK NIL (CL:LABELS ((~G1572 (~G41) (CL:LABELS ((~G1573 (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 !))))) (~G1573 NIL)))) (~G1572 LST))))) (~G1571 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1574 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1574 (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 ((~G1575 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1575 (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 ((~G1576 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1576 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1577 (~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)) (~G1577 (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 ((~G1578 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1578 (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 ((~G1579 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1579 (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 ((~G1580 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1580 (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 ((~G1581 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1582 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1582 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1581 (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 ((~G1583 (~G232) (CL:COND (~G232 ~G232) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1583 (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 ((~G1584 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1584 (PEEK-CHAR STR))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1585 (~G110) (CL:LABELS ((~G1586 (SEQ) (CL:TAGBODY ~G108 (CL:COND ((NOT ~G110) (CL:GO ~G109))) (CL:SETQ SEQ (CL:CAR ~G110)) (CL:LABELS ((~G1587 (~G107) (CL:COND ((INTEGER< ~G107 0) (ERROR "Negative number of iterations: ~A." ~G107))) (CL:BLOCK NIL (CL:LABELS ((~G1588 (!) (CL:TAGBODY ~G111 (CL:COND ((INTEGER== ! ~G107) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1589 (~G106) (CL:COND (~G106 ~G106) (T (CL:RETURN-FROM EVERY NIL))))) (~G1589 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G111)))) (~G1588 0))))) (~G1587 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G110 (CL:CDR ~G110)) (CL:GO ~G108) ~G109 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1586 NIL)))) (~G1585 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1590 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1590 (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 ((~G1591 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1591 (%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 ((~G1592 (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)))))))) (~G1592 (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 ((~G1593 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1593 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1594 (~G70) (CL:LABELS ((~G1595 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1596 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1596 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1595 NIL)))) (~G1594 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1597 (~G18) (CL:LABELS ((~G1598 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1599 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1600 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1600 (< N I))))))) (~G1599 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1598 NIL)))) (~G1597 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1601 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1602 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1603 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1604 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G1605 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1606 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G1607 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1608 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1609 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1610 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1611 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1612 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1613 (~G263) (CL:COND (~G263 ~G263) (T (== X #\^))))) (~G1613 (== X #\#))))))) (~G1612 (== X #\"))))))) (~G1611 (== X #\;))))))) (~G1610 (== X #\:))))))) (~G1609 (== X #\,))))))) (~G1608 (== X #\`))))))) (~G1607 (== X #\'))))))) (~G1606 (== X #\}))))))) (~G1605 (== X #\{))))))) (~G1604 (== X #\]))))))) (~G1603 (== X #\[))))))) (~G1602 (== X #\)))))))) (~G1601 (== 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 ((~G1614 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1614 (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 ((~G1615 (E) (CL:LABELS ((~G1616 (S) (CL:COND ((CL:LABELS ((~G1617 (~G103) (CL:COND (~G103 ~G103) (T (CL:COND ((< S E) FROM-END)))))) (~G1617 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1618 (~G104) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G104)))) (~G1618 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1619 (I) (CL:TAGBODY ~G105 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1620 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1620 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G105)))) (~G1619 S))))) (~G1616 (CL:LABELS ((~G1621 (~G102) (CL:COND (~G102 ~G102) (T 0)))) (~G1621 START)))))) (~G1615 (CL:LABELS ((~G1622 (~G101) (CL:COND (~G101 ~G101) (T (-- (CL:LENGTH SEQ)))))) (~G1622 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1623 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1624 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1625 (~G97) (CL:LABELS ((~G1626 (!) (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))))) (~G1626 NIL)))) (~G1625 !))))) (~G1624 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1627 (~G100) (CL:LABELS ((~G1628 (!) (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))))) (~G1628 NIL)))) (~G1627 !))))))) (~G1623 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1629 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1629 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1630 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1630 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- X #\0))))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  
negative.code: (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFUN COPY-HEAD (X SIZE) (CL:BLOCK COPY-HEAD (CL:BLOCK NIL (CL:COND ((CL:COND (X (< 0 SIZE))) (CL:CONS (CL:CAR X) (COPY-HEAD (CL:CDR X) (-- SIZE))))))))
  (CL:DEFUN CARLIST (~G126) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G126))))
  (CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1409 (~G189) (CL:LABELS ((~G1410 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1411 (A) (CL:LABELS ((~G1412 (~G191) (CL:LABELS ((~G1413 (K) (CL:LABELS ((~G1414 (ARGDEFS) (CL:LABELS ((~G1415 (KEY-ARGS) (CL:LABELS ((~G1416 (NUM) (CL:LABELS ((~G1417 (NO-STATIC) (CL:LABELS ((~G1418 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "; Call of function ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "static argument definition after ~A" (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "argument ~A missing" (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL" (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1419 (K) (CL:COND (K (CL:LABELS ((~G1420 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1420 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1419 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1421 (~G187) (CL:COND ((EQ ~G187 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G187 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G187 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1421 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "static sublevel argument definition after ~A" (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "sublist expected for argument ~A" (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "too many arguments. ~A max, but ~A more given" (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1422 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1422 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1423 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G1423 (EXP-MAIN ARGDEFS ALST)))))) (~G1418 NIL)))) (~G1417 NIL)))) (~G1416 0)))) (~G1415 K)))) (~G1414 A)))) (~G1413 (CL:CAR ~G191))))) (~G1412 (CL:LABELS ((~G1424 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1424 (CL:CDR ~G190))))))) (~G1411 (CL:CAR ~G190))))) (~G1410 (CL:CDR ~G189))))) (~G1409 (MAKE-&KEY-ALIST ADEF))))))
  (CL:DEFUN %MACROEXPAND-XLAT (X) (CL:SETQ *CURRENT-MACRO* (CL:CAR X)) (CL:LABELS ((~G1425 (X) (CL:SETQ *CURRENT-MACRO* NIL) X)) (~G1425 (CL:APPLY *MACROCALL* (CL:LIST X)))))
  (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-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1426 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1426 (%REST? X))))))
  (CL:DEFUN NATIVE-MACROEXPAND (X) (CL:LABELS ((~G1427 (PREDICATE CALLER CURRENT-MACRO) (CL:SETQ *MACRO?* (CL:FUNCTION %%MACRO?) *MACROCALL* (CL:FUNCTION %%MACROCALL) *CURRENT-MACRO* NIL) (CL:LABELS ((~G1428 (X) (CL:SETQ *MACRO?* PREDICATE *MACROCALL* CALLER *CURRENT-MACRO* CURRENT-MACRO) X)) (~G1428 (%MACROEXPAND X))))) (~G1427 *MACRO?* *MACROCALL* *CURRENT-MACRO*)))
  (CL:DEFUN ++ (X) (NUMBER+ X 1))
  (CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING 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 ((~G1429 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1429 START)))) (CL:LABELS ((~G1430 (~G65) (CL:COND ((CONS? ~G65) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G65) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G65) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1430 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1431 (~G112) (CL:LABELS ((~G1432 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1433 (NUM-CDRS) (CL:LABELS ((~G1434 (~G114) (CL:LABELS ((~G1435 (WITHOUT-START) (CL:LABELS ((~G1436 (~G117) (CL:LABELS ((~G1437 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1438 (NUM-CARS) (CL:LABELS ((~G1439 (~G119) (CL:LABELS ((~G1440 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1440 (CL:CAR ~G119))))) (~G1439 (CL:LABELS ((~G1441 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1441 (CL:CDR ~G118))))))) (~G1438 (CL:CAR ~G118))))) (~G1437 (CL:CDR ~G117))))) (~G1436 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1435 (CL:CAR ~G114))))) (~G1434 (CL:LABELS ((~G1442 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1442 (CL:CDR ~G113))))))) (~G1433 (CL:CAR ~G113))))) (~G1432 (CL:CDR ~G112))))) (~G1431 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1443 (SL) (CL:LABELS ((~G1444 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1444 (== #\. (CL:CAR SL)))))) (~G1443 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1445 (SL) (CL:LABELS ((~G1446 (L) (CL:LABELS ((~G1447 (P) (CL:LABELS ((~G1448 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1448 (== 1 L))))) (~G1447 (DOT-POSITION SL))))) (~G1446 (CL:LENGTH SL))))) (~G1445 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION ==)))))
  (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 WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((< X 33) (>= X 0))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1449 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1449 (READ-CHAR STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1450 (~G277) (CL:COND ((EQ ~G277 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G277 'CHAR) (READ-CHAR STR)) ((EQ ~G277 'NUMBER) (CL:LABELS ((~G1451 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1451 (MAKE-STRING-STREAM)))) ((EQ ~G277 'HEXNUM) (READ-HEX STR)) ((EQ ~G277 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G277 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1452 (~G276) (CL:COND ((EQUAL ~G276 'BRACKET-CLOSE) "Round") ((EQUAL ~G276 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G276 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1452 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1450 TOKEN)))))
  (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 ((~G1453 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1454 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1455 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1456 (~G248) (CL:COND (~G248 ~G248) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1456 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1455 (EQ X 'QUASIQUOTE))))))) (~G1454 (EQ X 'BACKQUOTE))))))) (~G1453 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1457 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1458 (~G311) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G305)) ~G311)) (~G1458 (CL:PROGN (CL:LABELS ((~G1459 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1460 (~G306) (CL:LABELS ((~G1461 (~G307) (CL:COND ((NOT (EQ (CL:CAR ~G306) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G306)))) (CL:LABELS ((~G1462 (TOKEN) (CL:LABELS ((~G1463 (~G308) (CL:LABELS ((~G1464 (PKG) (CL:LABELS ((~G1465 (~G309) (CL:LABELS ((~G1466 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1466 (CL:CAR ~G309))))) (~G1465 (CL:LABELS ((~G1467 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1467 (CL:CDR ~G308))))))) (~G1464 (CL:CAR ~G308))))) (~G1463 (CL:LABELS ((~G1468 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1468 (CL:CDR ~G307))))))) (~G1462 (CL:CAR ~G307))))) (~G1461 (CL:CDR ~G306))))) (~G1460 (READ-TOKEN STR))))) (T !)))) (~G1459 (READ-CONS STR)))))))) (~G1457 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1469 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1470 (~G271) (CL:LABELS ((~G1471 (~G272) (CL:COND ((NOT (EQ (CL:CAR ~G271) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G271)))) (CL:LABELS ((~G1472 (PKG) (CL:LABELS ((~G1473 (~G273) (CL:LABELS ((~G1474 (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 ((~G1475 (~G270) (CL:COND ((CHARACTER== ~G270 #\() 'BRACKET-OPEN) ((CHARACTER== ~G270 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G270 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G270 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G270 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G270 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G270 #\') 'CL:QUOTE) ((CHARACTER== ~G270 #\`) 'BACKQUOTE) ((CHARACTER== ~G270 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G270 #\") 'DBLQUOTE) ((CHARACTER== ~G270 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G270 #\#) (CL:LABELS ((~G1476 (~G269) (CL:COND ((CHARACTER== ~G269 #\\) 'CHAR) ((CHARACTER== ~G269 #\x) 'HEXNUM) ((CHARACTER== ~G269 #\') 'CL:FUNCTION) ((CHARACTER== ~G269 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1476 (READ-CHAR STR)))) ((CHARACTER== ~G270 -1) 'EOF)))) (~G1475 (READ-CHAR STR))))))) PKG SYM))) (~G1474 (CL:CAR ~G273))))) (~G1473 (CL:LABELS ((~G1477 (~G275) (CL:COND (~G275 ~G275) (T (%ERROR "Not enough VALUES."))))) (~G1477 (CL:CDR ~G272))))))) (~G1472 (CL:CAR ~G272))))) (~G1471 (CL:CDR ~G271))))) (~G1470 !))))))) (~G1469 (GET-SYMBOL-AND-PACKAGE STR))))))
  (CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  (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 ((~G1478 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1478 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1479 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1479 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1480 (~G177) (CL:LABELS ((~G1481 (S) (CL:LABELS ((~G1482 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1482 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1481 (DEFAULT-STREAM ~G177))))) (~G1480 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1483 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1483 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1484 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1484 X)))))
  (CL:DEFUN -- (X) (NUMBER- X 1))
  (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 ((~G1485 (~G157) (CL:PROGN (=-AREF 'STRUCT ~G157 0) (=-AREF 'STREAM ~G157 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G157 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G157 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G157 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G157 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G157 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G157 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G157 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T OUTPUT-LOCATION)) ~G157 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G157 10)) ~G157)) (~G1485 (MAKE-ARRAY 11))))))
  (CL:DEFVAR *CURRENT-MACRO*)
  (CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
  (CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
  (CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G1486 (~G164) (CL:LABELS ((~G1487 (!) (CL:TAGBODY ~G162 (CL:COND ((NOT ~G164) (CL:GO ~G163))) (CL:SETQ ! (CL:CAR ~G164)) (STREAM-PRINC ! STR) (CL:SETQ ~G164 (CL:CDR ~G164)) (CL:GO ~G162) ~G163 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1487 NIL)))) (~G1486 X)))) ((CL:LABELS ((~G1488 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1488 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (ERROR "Can only print strings and characters. Got ~A." X))))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION STRING-CONCAT) (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((STRING? _) _) ((CHARACTER? _) (STRING _))))) (QUEUE-LIST X))))))
  (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
  (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G265 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G265)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1489 (~G267) (CL:COND (~G267 ~G267) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1489 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1490 (~G266) (CL:COND (~G266 ~G266) (T (== #\. (CL:CAR X)))))) (~G1490 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1491 (~G268) (CL:COND (~G268 ~G268) (T (== #\. _))))) (~G1491 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1492 (SYM) (CL:LABELS ((~G1493 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1494 (~G264) (CL:COND (~G264 ~G264) (T T)))) (~G1494 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1493 (PEEK-CHAR STR))))) (~G1492 (GET-SYMBOL STR))))))
  (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 READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1495 (LOC) (CL:LABELS ((~G1496 (LINE) (CL:LABELS ((~G1497 (COLUMN) (CL:LABELS ((~G1498 (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 ((~G1499 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1500 (~G282) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G279)) ~G282)) (~G1500 (CL:PROGN (CL:LABELS ((~G1501 (~G278) (CL:COND ((EQ ~G278 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G278 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G278 '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))))))) (~G1501 TOKEN))))))) (~G1499 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1502 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1503 (~G288) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G281)) ~G288)) (~G1503 (CL:PROGN (CL:LABELS ((~G1504 (!) (CL:COND (! (CL:LABELS ((~G1505 (~G283) (CL:LABELS ((~G1506 (~G284) (CL:COND ((NOT (EQ (CL:CAR ~G283) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G283)))) (CL:LABELS ((~G1507 (TOKEN) (CL:LABELS ((~G1508 (~G285) (CL:LABELS ((~G1509 (PKG) (CL:LABELS ((~G1510 (~G286) (CL:LABELS ((~G1511 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1512 (X) (CL:LABELS ((~G1513 (~G291) (CL:LABELS ((~G1514 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1515 (TOKEN) (CL:LABELS ((~G1516 (~G293) (CL:LABELS ((~G1517 (PKG) (CL:LABELS ((~G1518 (~G294) (CL:LABELS ((~G1519 (SYM) (CL:LABELS ((~G1520 (~G280) (CL:COND (~G280 ~G280) (T (ERR "Only one value allowed after dotted cons."))))) (~G1520 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1519 (CL:CAR ~G294))))) (~G1518 (CL:LABELS ((~G1521 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1521 (CL:CDR ~G293))))))) (~G1517 (CL:CAR ~G293))))) (~G1516 (CL:LABELS ((~G1522 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1522 (CL:CDR ~G292))))))) (~G1515 (CL:CAR ~G292))))) (~G1514 (CL:CDR ~G291))))) (~G1513 (READ-TOKEN STR))))) (~G1512 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1511 (CL:CAR ~G286))))) (~G1510 (CL:LABELS ((~G1523 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1523 (CL:CDR ~G285))))))) (~G1509 (CL:CAR ~G285))))) (~G1508 (CL:LABELS ((~G1524 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1524 (CL:CDR ~G284))))))) (~G1507 (CL:CAR ~G284))))) (~G1506 (CL:CDR ~G283))))) (~G1505 !))) (T (ERR "Closing bracket missing."))))) (~G1504 (READ-TOKEN STR)))))))) (~G1502 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1525 (~G298) (CL:LABELS ((~G1526 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1527 (TOKEN) (CL:LABELS ((~G1528 (~G300) (CL:LABELS ((~G1529 (PKG) (CL:LABELS ((~G1530 (~G301) (CL:LABELS ((~G1531 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1531 (CL:CAR ~G301))))) (~G1530 (CL:LABELS ((~G1532 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1532 (CL:CDR ~G300))))))) (~G1529 (CL:CAR ~G300))))) (~G1528 (CL:LABELS ((~G1533 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1533 (CL:CDR ~G299))))))) (~G1527 (CL:CAR ~G299))))) (~G1526 (CL:CDR ~G298))))) (~G1525 (READ-TOKEN STR)))))) (~G1498 (STREAM-LOCATION-ID LOC))))) (~G1497 (STREAM-LOCATION-COLUMN LOC))))) (~G1496 (STREAM-LOCATION-LINE LOC))))) (~G1495 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1534 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1534 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1535 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1536 (~G250) (CL:COND (~G250 ~G250) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1536 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1535 (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 ((~G1537 (!) (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)))))))))) (~G1537 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1538 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1538 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1539 (~G235) (CL:COND (~G235 ~G235) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1539 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1540 (~G236) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G236)) (~G1540 (REC 0)))))))
  (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 ((~G1541 (~G237) (CL:COND (~G237 ~G237) (T 0)))) (~G1541 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  (CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1542 (~G175) (CL:LABELS ((~G1543 (S) (CL:LABELS ((~G1544 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1544 (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))))) (~G1543 (DEFAULT-STREAM ~G175))))) (~G1542 STR)))))
  (CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (STR) (CL:LABELS ((~G1545 (!) (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 !)))))))) (~G1545 (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))))))))
  (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (LIST-STRING (READ-STRING-0 STR)))))
  (CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1546 (~G13) (CL:LABELS ((~G1547 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1548 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1549 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1549 (> N I))))))) (~G1548 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1547 NIL)))) (~G1546 X))))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1550 (STREAM-LOCATION) (CL:LABELS ((~G1551 (TRACK?) (CL:LABELS ((~G1552 (ID) (CL:LABELS ((~G1553 (LINE) (CL:LABELS ((~G1554 (COLUMN) (CL:LABELS ((~G1555 (TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1556 (~G160) (CL:LABELS ((~G1557 (!) (CL:TAGBODY ~G158 (CL:COND ((NOT ~G160) (CL:GO ~G159))) (CL:SETQ ! (CL:CAR ~G160)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G160 (CL:CDR ~G160)) (CL:GO ~G158) ~G159 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1557 NIL)))) (~G1556 (STRING-LIST X))))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 X) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 STREAM-LOCATION)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE STREAM-LOCATION) 1) STREAM-LOCATION)))) (T (CL:COND ((== 9 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G1555 (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))) (~G1554 (STREAM-LOCATION-COLUMN STREAM-LOCATION))))) (~G1553 (STREAM-LOCATION-LINE STREAM-LOCATION))))) (~G1552 (STREAM-LOCATION-ID STREAM-LOCATION))))) (~G1551 (STREAM-LOCATION-TRACK? STREAM-LOCATION))))) (~G1550 STREAM-LOCATION)))))
  (CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
  (CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1558 (!) (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) !)) (~G1558 NIL)))))
  (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 %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1559 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1560 (L) (CL:LABELS ((~G1561 (S) (CL:LABELS ((~G1562 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1563 (X) (CL:TAGBODY ~G63 (CL:COND ((INTEGER== X ~G62) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G63)))) (~G1563 0))))) (~G1562 (INTEGER L))))) (~G1561 (FUNCALL MAKER L))))) (~G1560 (- END START)))))))) (~G1559 (CL:LENGTH SEQ)))))))))
  (CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1564 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1565 (L) (CL:LABELS ((~G1566 (S) (CL:LABELS ((~G1567 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1568 (X) (CL:TAGBODY ~G60 (CL:COND ((INTEGER== X ~G59) (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 ~G60)))) (~G1568 0))))) (~G1567 (INTEGER L))))) (~G1566 (CL:MAKE-STRING 0))))) (~G1565 (- END START)))))))) (~G1564 (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 ((~G1569 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1569 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 %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (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 KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  