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 ((~G1322 (~G1272) (CL:COND (~G1272 ~G1272) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G1322 (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 ((~G1321 (~G1271) (CL:COND (~G1271 ~G1271) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G1321 (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 ((~G1323 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1323 (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 ((~G1324 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1324 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1322 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1322 (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 ((~G1323 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1323 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 ((~G1325 (~G1274) (CL:COND (~G1274 ~G1274) (T NIL)))) (~G1325 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 ((~G1324 (~G1273) (CL:COND (~G1273 ~G1273) (T NIL)))) (~G1324 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 ((~G1326 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1326 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  -(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1327 (~G1278) (CL:LABELS ((~G1328 (I) (CL:TAGBODY ~G1276 (CL:COND ((NOT ~G1278) (CL:GO ~G1277))) (CL:SETQ I (CL:CAR ~G1278)) (EVAL (%EXPAND I)) (CL:SETQ ~G1278 (CL:CDR ~G1278)) (CL:GO ~G1276) ~G1277 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1328 NIL)))) (~G1327 (CL:LABELS ((~G1329 (S) (CL:LABELS ((~G1330 (~G1275) (CLOSE S) ~G1275)) (~G1330 (CL:BLOCK NIL (%LOAD-R S)))))) (~G1329 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
  +(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G1325 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1325 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  +(CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1326 (~G1277) (CL:LABELS ((~G1327 (I) (CL:TAGBODY ~G1275 (CL:COND ((NOT ~G1277) (CL:GO ~G1276))) (CL:SETQ I (CL:CAR ~G1277)) (EVAL (%EXPAND I)) (CL:SETQ ~G1277 (CL:CDR ~G1277)) (CL:GO ~G1275) ~G1276 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1327 NIL)))) (~G1326 (CL:LABELS ((~G1328 (S) (CL:LABELS ((~G1329 (~G1274) (CLOSE S) ~G1274)) (~G1329 (CL:BLOCK NIL (%LOAD-R S)))))) (~G1328 (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 ((~G1331 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G1331 (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 ((~G1332 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G1332 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  +(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G1330 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G1330 (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 ((~G1331 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G1331 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
   (CL:DEFVAR *MACROEXPAND*)
  -(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G1333 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1333 (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 ((~G1332 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1332 (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 ((~G1334 (~G1279) (CL:COND (~G1279 ~G1279) (T (CL:CHARACTERP X))))) (~G1334 (CL:NUMBERP X)))) (CL:SETF (CL:GETHASH 'NUMBER? *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER?)))
  +(CL:PROGN (CL:DEFUN NUMBER? (X) (CL:LABELS ((~G1333 (~G1278) (CL:COND (~G1278 ~G1278) (T (CL:CHARACTERP X))))) (~G1333 (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: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 ((~G1405 (~G189) (CL:LABELS ((~G1406 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1407 (A) (CL:LABELS ((~G1408 (~G191) (CL:LABELS ((~G1409 (K) (CL:LABELS ((~G1410 (ARGDEFS) (CL:LABELS ((~G1411 (KEY-ARGS) (CL:LABELS ((~G1412 (NUM) (CL:LABELS ((~G1413 (NO-STATIC) (CL:LABELS ((~G1414 (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 ((~G1415 (K) (CL:COND (K (CL:LABELS ((~G1416 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1416 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1415 (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 ((~G1417 (~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))))) (~G1417 (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 ((~G1418 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1418 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1419 (!) (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)))))) (~G1419 (EXP-MAIN ARGDEFS ALST)))))) (~G1414 NIL)))) (~G1413 NIL)))) (~G1412 0)))) (~G1411 K)))) (~G1410 A)))) (~G1409 (CL:CAR ~G191))))) (~G1408 (CL:LABELS ((~G1420 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1420 (CL:CDR ~G190))))))) (~G1407 (CL:CAR ~G190))))) (~G1406 (CL:CDR ~G189))))) (~G1405 (MAKE-&KEY-ALIST ADEF))))))
  (CL:DEFUN %MACROEXPAND-XLAT (X) (CL:SETQ *CURRENT-MACRO* (CL:CAR X)) (CL:LABELS ((~G1421 (X) (CL:SETQ *CURRENT-MACRO* NIL) X)) (~G1421 (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 ((~G1422 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1422 (%REST? X))))))
  (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 ((~G1423 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1423 START)))) (CL:LABELS ((~G1424 (~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))))) (~G1424 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1425 (~G112) (CL:LABELS ((~G1426 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1427 (NUM-CDRS) (CL:LABELS ((~G1428 (~G114) (CL:LABELS ((~G1429 (WITHOUT-START) (CL:LABELS ((~G1430 (~G117) (CL:LABELS ((~G1431 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1432 (NUM-CARS) (CL:LABELS ((~G1433 (~G119) (CL:LABELS ((~G1434 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1434 (CL:CAR ~G119))))) (~G1433 (CL:LABELS ((~G1435 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1435 (CL:CDR ~G118))))))) (~G1432 (CL:CAR ~G118))))) (~G1431 (CL:CDR ~G117))))) (~G1430 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1429 (CL:CAR ~G114))))) (~G1428 (CL:LABELS ((~G1436 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1436 (CL:CDR ~G113))))))) (~G1427 (CL:CAR ~G113))))) (~G1426 (CL:CDR ~G112))))) (~G1425 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1437 (SL) (CL:LABELS ((~G1438 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1438 (== #\. (CL:CAR SL)))))) (~G1437 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1439 (SL) (CL:LABELS ((~G1440 (L) (CL:LABELS ((~G1441 (P) (CL:LABELS ((~G1442 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1442 (== 1 L))))) (~G1441 (DOT-POSITION SL))))) (~G1440 (CL:LENGTH SL))))) (~G1439 (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 ((~G1443 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1443 (READ-CHAR STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1444 (~G277) (CL:COND ((EQ ~G277 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G277 'CHAR) (READ-CHAR STR)) ((EQ ~G277 'NUMBER) (CL:LABELS ((~G1445 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1445 (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 ((~G1446 (~G276) (CL:COND ((EQUAL ~G276 'BRACKET-CLOSE) "Round") ((EQUAL ~G276 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G276 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1446 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1444 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 ((~G1447 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1448 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1449 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1450 (~G248) (CL:COND (~G248 ~G248) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1450 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1449 (EQ X 'QUASIQUOTE))))))) (~G1448 (EQ X 'BACKQUOTE))))))) (~G1447 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1451 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1452 (~G311) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G305)) ~G311)) (~G1452 (CL:PROGN (CL:LABELS ((~G1453 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1454 (~G306) (CL:LABELS ((~G1455 (~G307) (CL:COND ((NOT (EQ (CL:CAR ~G306) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G306)))) (CL:LABELS ((~G1456 (TOKEN) (CL:LABELS ((~G1457 (~G308) (CL:LABELS ((~G1458 (PKG) (CL:LABELS ((~G1459 (~G309) (CL:LABELS ((~G1460 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1460 (CL:CAR ~G309))))) (~G1459 (CL:LABELS ((~G1461 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1461 (CL:CDR ~G308))))))) (~G1458 (CL:CAR ~G308))))) (~G1457 (CL:LABELS ((~G1462 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1462 (CL:CDR ~G307))))))) (~G1456 (CL:CAR ~G307))))) (~G1455 (CL:CDR ~G306))))) (~G1454 (READ-TOKEN STR))))) (T !)))) (~G1453 (READ-CONS STR)))))))) (~G1451 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1463 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1464 (~G271) (CL:LABELS ((~G1465 (~G272) (CL:COND ((NOT (EQ (CL:CAR ~G271) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G271)))) (CL:LABELS ((~G1466 (PKG) (CL:LABELS ((~G1467 (~G273) (CL:LABELS ((~G1468 (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 ((~G1469 (~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 ((~G1470 (~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 '#'."))))) (~G1470 (READ-CHAR STR)))) ((CHARACTER== ~G270 -1) 'EOF)))) (~G1469 (READ-CHAR STR))))))) PKG SYM))) (~G1468 (CL:CAR ~G273))))) (~G1467 (CL:LABELS ((~G1471 (~G275) (CL:COND (~G275 ~G275) (T (%ERROR "Not enough VALUES."))))) (~G1471 (CL:CDR ~G272))))))) (~G1466 (CL:CAR ~G272))))) (~G1465 (CL:CDR ~G271))))) (~G1464 !))))))) (~G1463 (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 ((~G1472 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1472 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1473 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1473 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1474 (~G177) (CL:LABELS ((~G1475 (S) (CL:LABELS ((~G1476 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1476 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1475 (DEFAULT-STREAM ~G177))))) (~G1474 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1477 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1477 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1478 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1478 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 ((~G1479 (~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)) (~G1479 (MAKE-ARRAY 11))))))
  (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 ((~G1480 (~G164) (CL:LABELS ((~G1481 (!) (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))))) (~G1481 NIL)))) (~G1480 X)))) ((CL:LABELS ((~G1482 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1482 (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 ((~G1483 (~G267) (CL:COND (~G267 ~G267) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1483 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1484 (~G266) (CL:COND (~G266 ~G266) (T (== #\. (CL:CAR X)))))) (~G1484 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1485 (~G268) (CL:COND (~G268 ~G268) (T (== #\. _))))) (~G1485 (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 ((~G1486 (SYM) (CL:LABELS ((~G1487 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1488 (~G264) (CL:COND (~G264 ~G264) (T T)))) (~G1488 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1487 (PEEK-CHAR STR))))) (~G1486 (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 ((~G1489 (LOC) (CL:LABELS ((~G1490 (LINE) (CL:LABELS ((~G1491 (COLUMN) (CL:LABELS ((~G1492 (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 ((~G1493 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1494 (~G282) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G279)) ~G282)) (~G1494 (CL:PROGN (CL:LABELS ((~G1495 (~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))))))) (~G1495 TOKEN))))))) (~G1493 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1496 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1497 (~G288) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G281)) ~G288)) (~G1497 (CL:PROGN (CL:LABELS ((~G1498 (!) (CL:COND (! (CL:LABELS ((~G1499 (~G283) (CL:LABELS ((~G1500 (~G284) (CL:COND ((NOT (EQ (CL:CAR ~G283) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G283)))) (CL:LABELS ((~G1501 (TOKEN) (CL:LABELS ((~G1502 (~G285) (CL:LABELS ((~G1503 (PKG) (CL:LABELS ((~G1504 (~G286) (CL:LABELS ((~G1505 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1506 (X) (CL:LABELS ((~G1507 (~G291) (CL:LABELS ((~G1508 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1509 (TOKEN) (CL:LABELS ((~G1510 (~G293) (CL:LABELS ((~G1511 (PKG) (CL:LABELS ((~G1512 (~G294) (CL:LABELS ((~G1513 (SYM) (CL:LABELS ((~G1514 (~G280) (CL:COND (~G280 ~G280) (T (ERR "Only one value allowed after dotted cons."))))) (~G1514 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1513 (CL:CAR ~G294))))) (~G1512 (CL:LABELS ((~G1515 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1515 (CL:CDR ~G293))))))) (~G1511 (CL:CAR ~G293))))) (~G1510 (CL:LABELS ((~G1516 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1516 (CL:CDR ~G292))))))) (~G1509 (CL:CAR ~G292))))) (~G1508 (CL:CDR ~G291))))) (~G1507 (READ-TOKEN STR))))) (~G1506 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1505 (CL:CAR ~G286))))) (~G1504 (CL:LABELS ((~G1517 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1517 (CL:CDR ~G285))))))) (~G1503 (CL:CAR ~G285))))) (~G1502 (CL:LABELS ((~G1518 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1518 (CL:CDR ~G284))))))) (~G1501 (CL:CAR ~G284))))) (~G1500 (CL:CDR ~G283))))) (~G1499 !))) (T (ERR "Closing bracket missing."))))) (~G1498 (READ-TOKEN STR)))))))) (~G1496 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1519 (~G298) (CL:LABELS ((~G1520 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1521 (TOKEN) (CL:LABELS ((~G1522 (~G300) (CL:LABELS ((~G1523 (PKG) (CL:LABELS ((~G1524 (~G301) (CL:LABELS ((~G1525 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1525 (CL:CAR ~G301))))) (~G1524 (CL:LABELS ((~G1526 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1526 (CL:CDR ~G300))))))) (~G1523 (CL:CAR ~G300))))) (~G1522 (CL:LABELS ((~G1527 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1527 (CL:CDR ~G299))))))) (~G1521 (CL:CAR ~G299))))) (~G1520 (CL:CDR ~G298))))) (~G1519 (READ-TOKEN STR)))))) (~G1492 (STREAM-LOCATION-ID LOC))))) (~G1491 (STREAM-LOCATION-COLUMN LOC))))) (~G1490 (STREAM-LOCATION-LINE LOC))))) (~G1489 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1528 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1528 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1529 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1530 (~G250) (CL:COND (~G250 ~G250) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1530 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1529 (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 ((~G1531 (!) (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)))))))))) (~G1531 (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 ((~G1532 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1532 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1533 (~G235) (CL:COND (~G235 ~G235) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1533 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1534 (~G236) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G236)) (~G1534 (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 ((~G1535 (~G237) (CL:COND (~G237 ~G237) (T 0)))) (~G1535 (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 ((~G1536 (~G175) (CL:LABELS ((~G1537 (S) (CL:LABELS ((~G1538 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1538 (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))))) (~G1537 (DEFAULT-STREAM ~G175))))) (~G1536 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 ((~G1539 (!) (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 !)))))))) (~G1539 (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 ((~G1540 (~G13) (CL:LABELS ((~G1541 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1542 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1543 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1543 (> N I))))))) (~G1542 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1541 NIL)))) (~G1540 X))))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1544 (STREAM-LOCATION) (CL:LABELS ((~G1545 (TRACK?) (CL:LABELS ((~G1546 (ID) (CL:LABELS ((~G1547 (LINE) (CL:LABELS ((~G1548 (COLUMN) (CL:LABELS ((~G1549 (TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1550 (~G160) (CL:LABELS ((~G1551 (!) (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))))) (~G1551 NIL)))) (~G1550 (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)) (~G1549 (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))) (~G1548 (STREAM-LOCATION-COLUMN STREAM-LOCATION))))) (~G1547 (STREAM-LOCATION-LINE STREAM-LOCATION))))) (~G1546 (STREAM-LOCATION-ID STREAM-LOCATION))))) (~G1545 (STREAM-LOCATION-TRACK? STREAM-LOCATION))))) (~G1544 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 ((~G1552 (!) (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) !)) (~G1552 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 ((~G1553 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1554 (L) (CL:LABELS ((~G1555 (S) (CL:LABELS ((~G1556 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1557 (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)))) (~G1557 0))))) (~G1556 (INTEGER L))))) (~G1555 (FUNCALL MAKER L))))) (~G1554 (- END START)))))))) (~G1553 (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 ((~G1558 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1559 (L) (CL:LABELS ((~G1560 (S) (CL:LABELS ((~G1561 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1562 (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)))) (~G1562 0))))) (~G1561 (INTEGER L))))) (~G1560 (CL:MAKE-STRING 0))))) (~G1559 (- END START)))))))) (~G1558 (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 ((~G1563 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1563 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)))))))
  
negative.code: (CL:PROGN (CL:DEFUN STRING== (A B) (CL:STRING= A B)) (CL:SETF (CL:GETHASH 'STRING== *BUILTIN-ATOMS*) (CL:FUNCTION STRING==)))
  (CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:CONCATENATE 'CL:STRING (CL:MAPCAR (CL:LAMBDA (X) (CL:COND ((CL:NUMBERP X) (CL:CODE-CHAR X)) (T X))) X))) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
  (CL:DEFVAR *SPECIAL-FORMS*)
  (CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G1347 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G1347 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
  (CL:DEFUN SPECIAL-%%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ)))))))
  (CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G1348 (~G1290) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G1349 (~G1292) (CL:PROGN (CL:SETQ *MACRO?* ~G1290)) ~G1292)) (~G1349 (CL:PROGN (CL:LABELS ((~G1350 (~G1291) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G1351 (~G1293) (CL:PROGN (CL:SETQ *MACROCALL* ~G1291)) ~G1293)) (~G1351 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G1350 *MACROCALL*))))))) (~G1348 *MACRO?*)))
  (CL:DEFUN MAKE-%DEFUN-QUIET (NAME ARGS BODY) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',(CL:CONS ARGS BODY)) *FUNCTIONS*) (CL:DEFUN ,NAME ,ARGS ,@BODY)))
  (CL:DEFVAR *KEYWORD-PACKAGE*)
  (CL:PROGN (CL:DEFUN MAKE-SYMBOL (X CL:&OPTIONAL (PACKAGE NIL)) (CL:INTERN X (CL:COND ((CL:NOT PACKAGE) "TRE") ((CL:PACKAGEP PACKAGE) (CL:PACKAGE-NAME PACKAGE)) ((CL:SYMBOLP PACKAGE) (CL:SYMBOL-NAME PACKAGE)) (T PACKAGE)))) (CL:SETF (CL:GETHASH 'MAKE-SYMBOL *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-SYMBOL)))
  