anchor.diff:  (CL:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY (CL:FUNCTION %>) X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) (CL:FUNCTION >)))
   (CL:DEFUN BITS-INTEGER (BITS) (CL:REDUCE (CL:LAMBDA (A B) (+ (* A 2) B)) BITS))
   (CL:DEFUN NUMBER (X) (CL:COND ((CHARACTER? X) (CL:CHAR-CODE X)) (T X)))
  -(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G1370 (!) (CL:LABELS ((~G1371 (L) (CL:LABELS ((~G1372 (~G1316) (CL:COND ((INTEGER< ~G1316 0) (ERROR "Negative number of iterations: ~A." ~G1316))) (CL:BLOCK NIL (CL:LABELS ((~G1373 (I) (CL:TAGBODY ~G1317 (CL:COND ((INTEGER== I ~G1316) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (INTEGER+ 1 I)) (CL:GO ~G1317)))) (~G1373 0))))) (~G1372 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1371 NIL)))) (~G1370 (NUMBER X))))
  +(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G1132 (!) (CL:LABELS ((~G1133 (L) (CL:LABELS ((~G1134 (~G1073) (CL:COND ((INTEGER< ~G1073 0) (ERROR "Negative number of iterations: ~A." ~G1073))) (CL:BLOCK NIL (CL:LABELS ((~G1135 (I) (CL:TAGBODY ~G1074 (CL:COND ((INTEGER== I ~G1073) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (INTEGER+ 1 I)) (CL:GO ~G1074)))) (~G1135 0))))) (~G1134 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1133 NIL)))) (~G1132 (NUMBER X))))
   (CL:PROGN (CL:DEFUN BIT-AND (A B) (BITS-INTEGER (CL:BIT-AND (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-AND *BUILTIN-ATOMS*) (CL:FUNCTION BIT-AND)))
   (CL:PROGN (CL:DEFUN BIT-OR (A B) (BITS-INTEGER (CL:BIT-IOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-OR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-OR)))
   (CL:PROGN (CL:DEFUN BIT-XOR (A B) (BITS-INTEGER (CL:BIT-XOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-XOR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-XOR)))
  -(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1374 (!) (CL:LABELS ((~G1375 (~G1318) (CL:COND ((INTEGER< ~G1318 0) (ERROR "Negative number of iterations: ~A." ~G1318))) (CL:BLOCK NIL (CL:LABELS ((~G1376 (N) (CL:TAGBODY ~G1319 (CL:COND ((INTEGER== N ~G1318) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1319)))) (~G1376 0))))) (~G1375 (INTEGER BITS))))) (~G1374 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  -(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1377 (!) (CL:LABELS ((~G1378 (~G1320) (CL:COND ((INTEGER< ~G1320 0) (ERROR "Negative number of iterations: ~A." ~G1320))) (CL:BLOCK NIL (CL:LABELS ((~G1379 (N) (CL:TAGBODY ~G1321 (CL:COND ((INTEGER== N ~G1320) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1321)))) (~G1379 0))))) (~G1378 (INTEGER BITS))))) (~G1377 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
  +(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1136 (!) (CL:LABELS ((~G1137 (~G1075) (CL:COND ((INTEGER< ~G1075 0) (ERROR "Negative number of iterations: ~A." ~G1075))) (CL:BLOCK NIL (CL:LABELS ((~G1138 (N) (CL:TAGBODY ~G1076 (CL:COND ((INTEGER== N ~G1075) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1076)))) (~G1138 0))))) (~G1137 (INTEGER BITS))))) (~G1136 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  +(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1139 (!) (CL:LABELS ((~G1140 (~G1077) (CL:COND ((INTEGER< ~G1077 0) (ERROR "Negative number of iterations: ~A." ~G1077))) (CL:BLOCK NIL (CL:LABELS ((~G1141 (N) (CL:TAGBODY ~G1078 (CL:COND ((INTEGER== N ~G1077) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1078)))) (~G1141 0))))) (~G1140 (INTEGER BITS))))) (~G1139 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
   (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY (CL:FUNCTION CL:NOT) X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) (CL:FUNCTION NOT)))
  -(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1380 (~G1325) (CL:LABELS ((~G1381 (I) (CL:TAGBODY ~G1323 (CL:COND ((NOT ~G1325) (CL:GO ~G1324))) (CL:SETQ I (CL:CAR ~G1325)) (CL:LABELS ((~G1382 (~G1322) (CL:COND (~G1322 ~G1322) (T (CL:RETURN-FROM NIL NIL))))) (~G1382 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1325 (CL:CDR ~G1325)) (CL:GO ~G1323) ~G1324 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1381 NIL)))) (~G1380 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
  +(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1142 (~G1082) (CL:LABELS ((~G1143 (I) (CL:TAGBODY ~G1080 (CL:COND ((NOT ~G1082) (CL:GO ~G1081))) (CL:SETQ I (CL:CAR ~G1082)) (CL:LABELS ((~G1144 (~G1079) (CL:COND (~G1079 ~G1079) (T (CL:RETURN-FROM NIL NIL))))) (~G1144 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1082 (CL:CDR ~G1082)) (CL:GO ~G1080) ~G1081 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1143 NIL)))) (~G1142 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
   (CL:DEFUN TRE-EQL (A B) (CL:COND ((CL:COND ((NUMBER? A) (NUMBER? B))) (CL:COND ((CL:EQ (CL:CHARACTERP A) (CL:CHARACTERP B)) (== A B)))) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((TRE-EQL (CL:CAR A) (CL:CAR B)) (TRE-EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B)) (T (CL:EQ A B))))
   (CL:PROGN (CL:DEFUN EQ (CL:&REST X) (VARIABLE-COMPARE (CL:FUNCTION CL:EQ) X)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
   (CL:PROGN (CL:DEFUN EQL (CL:&REST X) (VARIABLE-COMPARE (CL:FUNCTION TRE-EQL) X)) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  
positive.code: (CL:PROGN (CL:DEFUN NUMBER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'NUMBER> *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER>)))
  (CL:PROGN (CL:DEFUN INTEGER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'INTEGER> *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER>)))
  (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1388 (TESTS) (CL:LABELS ((~G1389 (END) (CL:COND ((NOT BODY) (CL:PROGN (ERROR "Body is missing.")))) (CL:CONS 'CL:COND (APPEND (CL:COND ((SOLE? END) (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END)))) (T TESTS)) NIL)))) (~G1389 (CL:CAR (CL:LAST TESTS)))))) (~G1388 (GROUP BODY 2))))))
  (CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1390 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1390 (CL:APPLY *MACROCALL* (CL:LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1391 (~G131) (CL:LABELS ((~G1392 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1392 NIL)))) (~G1391 LST))))))))
  (CL:DEFUN TRE-SYMBOL (X) (CL:BLOCK TRE-SYMBOL (CL:BLOCK NIL (CL:INTERN (SYMBOL-NAME X) "TRE"))))
  (CL:DEFUN CLOSE (STR) (CL:BLOCK CLOSE (CL:BLOCK NIL (%FCLOSE (STREAM-HANDLE STR)))))
  (CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1393 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1393 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  (CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1394 (~G125) (CL:LABELS ((~G1395 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1395 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1394 X)) (CL:LABELS ((~G1396 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1396 *DEFAULT-LISTPROP*)))) (T X)))))
  (CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (SKIP-SPACES STR) (CL:COND ((PEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1397 (~G234) (CL:COND (~G234 ~G234) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1397 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1398 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1399 (~G335) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G334)) ~G335)) (~G1399 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1398 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1400 (~G734) (CL:COND ((CL:ATOM ~G734) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G734) (QQ _)) ((QUASIQUOTE-SPLICE? ~G734) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1400 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1401 (~G735) (CL:COND ((QUOTE? ~G735) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G735) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1401 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING (CL:FUNCTION DISP)))))))
  (CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((== _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1402 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1402 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  (CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  (CL:DEFUN GENSYM NIL (CL:LABELS ((~G1403 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1403 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1404 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1404 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-PREFIX*)
  (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
  
negative.code: (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 ((~G1119 (~G1064) (CL:COND (~G1064 ~G1064) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G1119 (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 ((~G1120 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1120 (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 ((~G1121 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1121 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 ((~G1122 (~G1066) (CL:COND (~G1066 ~G1066) (T NIL)))) (~G1122 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 ((~G1123 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G1123 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  (CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(%LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G1124 (~G1070) (CL:LABELS ((~G1125 (I) (CL:TAGBODY ~G1068 (CL:COND ((NOT ~G1070) (CL:GO ~G1069))) (CL:SETQ I (CL:CAR ~G1070)) (EVAL (%EXPAND I)) (CL:SETQ ~G1070 (CL:CDR ~G1070)) (CL:GO ~G1068) ~G1069 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1125 NIL)))) (~G1124 (CL:LABELS ((~G1126 (S) (CL:LABELS ((~G1127 (~G1067) (CLOSE S) ~G1067)) (~G1127 (CL:BLOCK NIL (%LOAD-R S)))))) (~G1126 (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 ((~G1128 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G1128 (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 ((~G1129 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G1129 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  (CL:DEFVAR *MACROEXPAND*)
  (CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G1130 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G1130 (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 ((~G1131 (~G1071) (CL:COND (~G1071 ~G1071) (T (CL:CHARACTERP X))))) (~G1131 (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)))
  