anchor.diff:  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CODE-CHAR (- (+ (CL:CHAR-CODE C) (CL:CHAR-CODE #\A)) (CL:CHAR-CODE #\a)))) (T C)))))
   (CL:DEFUN =-FORMAT-INFO-PROCESSED-ARGS (VAL ARR) (CL:BLOCK =-FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
   (CL:DEFUN FORMAT-INFO-PROCESSED-ARGS (ARR) (CL:BLOCK FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:AREF ARR 5))))
  -(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G900 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G900 (CL:CAR LSTS)))))))))
  -(CL:DEFUN %FORMAT-DIRECTIVE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE (CL:BLOCK NIL (CL:PROGN (=-FORMAT-INFO-PROCESSED-ARGS (NUMBER+ (FORMAT-INFO-PROCESSED-ARGS INF) 1) INF)) (CL:LABELS ((~G901 (~G297) (CL:COND ((EQL ~G297 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\L) (%FORMAT-DIRECTIVE-FRESH-LINE INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\~) (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G901 (CHAR-UPCASE (CL:CAR TXT)))))))
  +(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G901 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G901 (CL:CAR LSTS)))))))))
  +(CL:DEFUN %FORMAT-DIRECTIVE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE (CL:BLOCK NIL (CL:PROGN (=-FORMAT-INFO-PROCESSED-ARGS (NUMBER+ (FORMAT-INFO-PROCESSED-ARGS INF) 1) INF)) (CL:LABELS ((~G902 (~G297) (CL:COND ((EQL ~G297 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\L) (%FORMAT-DIRECTIVE-FRESH-LINE INF (CL:CDR TXT) ARGS)) ((EQL ~G297 #\~) (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G902 (CHAR-UPCASE (CL:CAR TXT)))))))
   (CL:DEFUN FORMAT-INFO-STREAM (ARR) (CL:BLOCK FORMAT-INFO-STREAM (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
   (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
  
positive.code: (CL:DEFVAR *QUASIQUOTE-EXPAND*)
  (CL:DEFVAR *DOT-EXPAND*)
  (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
  (CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G762 (~G735) (CL:COND (~G735 ~G735) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G762 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-ARRAY)))
  (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) (CL:FUNCTION =-AREF)))
  (CL:DEFVAR *ENVIRONMENT-PATH*)
  (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
  (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&REST TARGETS) (PRINT-DEFINITION `(ENV-LOAD ,PATHNAME ,@TARGETS)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGETS) *ENVIRONMENT-FILENAMES*)) (CL:COND ((CL:LABELS ((~G763 (~G736) (CL:COND (~G736 ~G736) (T (MEMBER :CL TARGETS))))) (~G763 (NOT TARGETS))) (CL:PROGN (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME)))))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
  (CL:DEFVAR +ANONYMOUS-FUNCTION-SOURCES?+)
  (CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G764 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G764 (GENSYM))))
  (CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G765 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G765 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  (CL:DEFUN LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (CL:ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
  (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((CL:ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (DYNAMIC-MAP (CL:FUNCTION MAKE-LAMBDAS) X))))
  (CL:PROGN (CL:DEFUN %ERROR (MSG) (CL:BREAK (NEUTRALIZE-FORMAT-STRING MSG))) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) (CL:FUNCTION %ERROR)))
  (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
  (CL:DEFVAR *EVAL*)
  (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
  (CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G766 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G767 (~G738) (CL:COND (~G738 (CL:PROGN (CL:LABELS ((~G768 (~G740) (CL:BLOCK NIL (CL:LABELS ((~G769 (~G739) (CL:TAGBODY ~G741 (CL:COND ((== ~G739 ~G740) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G770 (I) (%PRINC I !))) (~G770 (ELT ~G738 ~G739))) (CL:SETQ ~G739 (NUMBER+ 1 ~G739)) (CL:GO ~G741)))) (~G769 0))))) (~G768 (INTEGER (CL:LENGTH ~G738))))))))) (~G767 X))) (T (CL:PRINC X !))))) (~G766 (CL:LABELS ((~G771 (~G737) (CL:COND (~G737 ~G737) (T CL:*STANDARD-OUTPUT*)))) (~G771 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
  (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
  (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
  (CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G772 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G772 (CL:READ-BYTE (CL:LABELS ((~G773 (~G742) (CL:COND (~G742 ~G742) (T CL:*STANDARD-INPUT*)))) (~G773 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  (CL:PROGN (CL:DEFUN FILE-EXISTS? (PATHNAME) (CL:COND ((CL:PROBE-FILE PATHNAME) T))) (CL:SETF (CL:GETHASH 'FILE-EXISTS? *BUILTIN-ATOMS*) (CL:FUNCTION FILE-EXISTS?)))
  (CL:DEFVAR *FUNCTIONS*)
  (CL:PROGN (CL:DEFUN FUNCTION-NATIVE (X) X) (CL:SETF (CL:GETHASH 'FUNCTION-NATIVE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-NATIVE)))
  (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 ((~G774 (~G743) (CL:COND (~G743 ~G743) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G774 (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 ((~G775 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G775 (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 ((~G776 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G776 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 ((~G777 (~G744) (CL:COND (~G744 ~G744) (T NIL)))) (~G777 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
  (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) (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 ((~G778 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G778 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  (CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G779 (~G748) (CL:LABELS ((~G780 (I) (CL:TAGBODY ~G746 (CL:COND ((NOT ~G748) (CL:GO ~G747))) (CL:SETQ I (CL:CAR ~G748)) (EVAL (%EXPAND I)) (CL:SETQ ~G748 (CL:CDR ~G748)) (CL:GO ~G746) ~G747 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G780 NIL)))) (~G779 (CL:LABELS ((~G781 (S) (CL:LABELS ((~G782 (~G745) (CLOSE S) ~G745)) (~G782 (CL:BLOCK NIL (%LOAD-R S)))))) (~G781 (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 ((~G783 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G783 (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 ((~G784 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G784 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  (CL:DEFVAR *MACROEXPAND*)
  (CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G785 (!) (CL:COND (! (CL:APPLY ! (CL:LIST X))) (T X)))) (~G785 (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 CODE-CHAR (X) (CL:COND ((CL:CHARACTERP X) X) (T (CL:CODE-CHAR X)))) (CL:SETF (CL:GETHASH 'CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CODE-CHAR)))
  (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 ((~G786 (!) (CL:LABELS ((~G787 (L) (CL:LABELS ((~G788 (~G749) (CL:BLOCK NIL (CL:LABELS ((~G789 (I) (CL:TAGBODY ~G750 (CL:COND ((== I ~G749) (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 (NUMBER+ 1 I)) (CL:GO ~G750)))) (~G789 0))))) (~G788 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G787 NIL)))) (~G786 (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 ((~G790 (~G751) (CL:BLOCK NIL (CL:LABELS ((~G791 (N) (CL:TAGBODY ~G752 (CL:COND ((== N ~G751) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE X 2) (CL:PROGN (CL:SETQ X I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G752)))) (~G791 0))))) (~G790 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G792 (~G753) (CL:BLOCK NIL (CL:LABELS ((~G793 (N) (CL:TAGBODY ~G754 (CL:COND ((== N ~G753) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:PROGN (CL:SETQ X (* X 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G754)))) (~G793 0))))) (~G792 (INTEGER BITS)))) (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:PROGN (CL:DEFUN EQ (A B) (CL:EQ A B)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
  (CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G794 (~G755) (CL:COND (~G755 ~G755) (T (CL:COND ((CL:COND ((CL:CHARACTERP A) (CL:CHARACTERP B))) (CL:= (CL:CHAR-CODE A) (CL:CHAR-CODE B))) ((CL:COND ((NOT (CL:CHARACTERP A) (CL:CHARACTERP B)) (CL:COND ((NUMBER? A) (NUMBER? B))))) (CL:= A B)) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((EQL (CL:CAR A) (CL:CAR B)) (EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B))))))) (~G794 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  (CL:PROGN (CL:DEFUN ELT (SEQ IDX) (CL:COND (SEQ (CL:COND ((CL:< IDX (CL:LENGTH SEQ)) (CL:ELT SEQ IDX)))))) (CL:SETF (CL:GETHASH 'ELT *BUILTIN-ATOMS*) (CL:FUNCTION ELT)))
  (CL:PROGN (CL:DEFUN %SET-ELT (OBJ SEQ IDX) (CL:SETF (CL:ELT SEQ IDX) OBJ)) (CL:SETF (CL:GETHASH '%SET-ELT *BUILTIN-ATOMS*) (CL:FUNCTION %SET-ELT)))
  (CL:PROGN (CL:DEFUN STRING-CONCAT (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CONCATENATE) 'CL:STRING X)) (CL:SETF (CL:GETHASH 'STRING-CONCAT *BUILTIN-ATOMS*) (CL:FUNCTION STRING-CONCAT)))
  (CL:PROGN (CL:DEFUN STRING (X) (CL:COND ((CL:NUMBERP X) (CL:FORMAT NIL "~A" X)) (T (CL:STRING X)))) (CL:SETF (CL:GETHASH 'STRING *BUILTIN-ATOMS*) (CL:FUNCTION STRING)))
  (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:LABELS ((~G795 (~G756) (CL:COND (~G756 ~G756) (T (ERROR "List expected instead of ~A." X))))) (~G795 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
  (CL:DEFVAR *SPECIAL-FORMS*)
  (CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G796 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G796 (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 ((~G797 (~G757) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G798 (~G758) (CL:PROGN (CL:SETQ *MACRO?* ~G757)) ~G758)) (~G798 (CL:PROGN (CL:LABELS ((~G799 (~G759) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G800 (~G760) (CL:PROGN (CL:SETQ *MACROCALL* ~G759)) ~G760)) (~G800 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G799 *MACROCALL*))))))) (~G797 *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:DEFVAR *PACKAGE*)
  (CL:PROGN (CL:DEFUN MAKE-SYMBOL (X CL:&OPTIONAL (PACKAGE NIL)) (CL:INTERN X (CL:COND ((CL:NOT PACKAGE) (CL:LABELS ((~G801 (~G761) (CL:COND (~G761 ~G761) (T "TRE")))) (~G801 (CL:LABELS ((~G802 (!) (CL:COND (! (SYMBOL-NAME !))))) (~G802 *PACKAGE*))))) ((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)))
  (CL:PROGN (CL:DEFUN SYMBOL-NAME (X) (CL:COND ((CL:PACKAGEP X) (CL:PACKAGE-NAME X)) (T (CL:SYMBOL-NAME X)))) (CL:SETF (CL:GETHASH 'SYMBOL-NAME *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-NAME)))
  (CL:PROGN (CL:DEFUN SYMBOL-VALUE (X) (CL:COND ((CL:BOUNDP X) (CL:SYMBOL-VALUE X)) (T X))) (CL:SETF (CL:GETHASH 'SYMBOL-VALUE *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-VALUE)))
  (CL:PROGN (CL:DEFUN SYMBOL-FUNCTION (X) (CL:COND ((CL:FBOUNDP X) (CL:SYMBOL-FUNCTION X)))) (CL:SETF (CL:GETHASH 'SYMBOL-FUNCTION *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-FUNCTION)))
  
negative.code: ; tré Common Lisp core, generated by 'makefiles/boot-common.lisp'.
  (declaim #+sbcl(sb-ext:muffle-conditions compiler-note style-warning))
  (DEFPACKAGE "TRE-CORE" (:EXPORT "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "BACKQUOTE" "QUASIQUOTE" "QUASIQUOTE-SPLICE" "SQUARE" "CURLY" "ACCENT-CIRCONFLEX" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK" "POW" "CHARACTER>" "CHARACTER<" "CHARACTER==" "NUMBER>" "NUMBER<" "NUMBER/" "NUMBER*" "NUMBER-" "NUMBER+" "NUMBER==" "%/" "%*" ">=" "<=" ">" "<" "==" "/" "*" "-" "%CODE-CHAR" "INTEGER" "CHARACTER?" "NUMBER?" "ARRAY?" "STRING?" "FUNCTION?" "SYMBOL?" "CONS?" "NANOTIME" "UNIX-SH-RM" "UNIX-SH-MKDIR" "UNIX-SH-CP" "SH" "FIND-SYMBOL" "=-SYMBOL-FUNCTION" "SYMBOL-PACKAGE" "SYMBOL-FUNCTION" "SYMBOL-VALUE" "SYMBOL-NAME" "MAKE-SYMBOL" "LIST-STRING" "STRING==" "STRING" "STRING-CONCAT" "%SET-ELT" "ELT" "EQL" "EQ" "NOT" "<<" ">>" "BIT-XOR" "BIT-OR" "BIT-AND" "CODE-CHAR" "NANOTIME" "QUIT" "MACROEXPAND" "MACROEXPAND-1" "%%MACRO?" "%%MACROCALL" "MACRO?" "LOAD" "APPEND" "FILTER" "%START-CORE" "SYS-IMAGE-CREATE" "HASHKEYS" "COPY-HASH-TABLE" "HREMOVE" "=-HREF" "HREF" "HASH-TABLE?" "MAKE-HASH-TABLE" "FUNCTION-BYTECODE" "=-FUNCTION-SOURCE" "FUNCTION-SOURCE" "FILE-EXISTS?" "%READ-CHAR" "%FCLOSE" "%FOPEN" "%FORCE-OUTPUT" "%PRINC" "EVAL" "%ERROR" "ENV-LOAD" "=-AREF" "MAKE-ARRAY" "BUILTIN?" "%DEFUN-QUIET" "%DEFUN" "%DEFVAR" "%DEFMACRO" "?" "*UNIVERSE*" "*VARIABLES*" "*FUNCTIONS*" "*ENVIRONMENT-PATH*" "*ENVIRONMENT-FILENAMES*" "*MACROEXPAND*" "*QUASIQUOTE-EXPAND*" "*DOT-EXPAND*" "*PACKAGE*" "*KEYWORD-PACKAGE*" "*POINTER-SIZE*" "*LAUNCHFILE*" "*ASSERT?*" "*TARGETS*" "*ENDIANESS*" "*CPU-TYPE*" "*LIBC-PATH*" "*RAND-MAX*" "*EVAL*" "CONS?" "SYMBOL?" "FUNCTION?" "STRING?" "ARRAY?" "NUMBER?" "CHARACTER?" "INTEGER" "%CODE-CHAR" "-" "*" "/" "==" "<" ">" "<=" ">=" "%*" "%/" "NUMBER==" "NUMBER+" "NUMBER-" "NUMBER*" "NUMBER/" "NUMBER<" "NUMBER>" "CHARACTER==" "CHARACTER<" "CHARACTER>" "POW") (:IMPORT-FROM "CL" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK"))
  (DEFPACKAGE "TRE" (:USE "TRE-CORE"))
  (CL:IN-PACKAGE :TRE-CORE)
  "Section CL-CORE"
  