anchor.diff:  (CL:DEFVAR *QUASIQUOTE-EXPAND*)
   (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST #'CL:EQ))
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1512 (~G1466) (CL:COND (~G1466 ~G1466) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1512 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) #'BUILTIN?))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1458 (~G1412) (CL:COND (~G1412 ~G1412) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1458 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) #'BUILTIN?))
   (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) #'MAKE-ARRAY))
   (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) #'=-AREF))
   (CL:DEFVAR *ENVIRONMENT-PATH*)
   (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
   (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&OPTIONAL (TARGET NIL)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGET) *ENVIRONMENT-FILENAMES*)) (LOAD (+  *ENVIRONMENT-PATH* "/environment/" PATHNAME))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) #'ENV-LOAD))
  -(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1513 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1513 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1514 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1514 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1459 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1459 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1460 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1460 (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 (CL:MAPCAR #'MAKE-LAMBDAS X))))
   (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
   (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (TRE2CL X))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) #'EVAL))
  -(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1515 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1516 (~G1468) (CL:COND ((INTEGER< ~G1468 0) (ERROR "Negative number of iterations: ~A."  ~G1468))) (CL:BLOCK NIL (CL:LABELS ((~G1517 (!) (CL:TAGBODY ~G1469 (CL:COND ((INTEGER== ! ~G1468) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1469)))) (~G1517 0))))) (~G1516 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1515 (CL:LABELS ((~G1518 (~G1467) (CL:COND (~G1467 ~G1467) (T CL:*STANDARD-OUTPUT*)))) (~G1518 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1461 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1462 (~G1414) (CL:COND ((INTEGER< ~G1414 0) (ERROR "Negative number of iterations: ~A."  ~G1414))) (CL:BLOCK NIL (CL:LABELS ((~G1463 (!) (CL:TAGBODY ~G1415 (CL:COND ((INTEGER== ! ~G1414) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1415)))) (~G1463 0))))) (~G1462 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1461 (CL:LABELS ((~G1464 (~G1413) (CL:COND (~G1413 ~G1413) (T CL:*STANDARD-OUTPUT*)))) (~G1464 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
   (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) #'%FORCE-OUTPUT))
   (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST #'CL:EQUAL) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) #'%FOPEN))
   (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) #'%FCLOSE))
  -(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1519 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1519 (CL:READ-BYTE (CL:LABELS ((~G1520 (~G1470) (CL:COND (~G1470 ~G1470) (T CL:*STANDARD-INPUT*)))) (~G1520 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1465 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1465 (CL:READ-BYTE (CL:LABELS ((~G1466 (~G1416) (CL:COND (~G1416 ~G1416) (T CL:*STANDARD-INPUT*)))) (~G1466 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
   (CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:ENSURE-DIRECTORIES-EXIST PATHNAME)) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) #'UNIX-SH-MKDIR))
   (CL:DEFVAR *FUNCTIONS*)
   (CL:PROGN (CL:DEFUN FUNCTION-NATIVE (X) X) (CL:SETF (CL:GETHASH 'FUNCTION-NATIVE *BUILTIN-ATOMS*) #'FUNCTION-NATIVE))
   (CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST #'CL:EQ))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) #'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*) #'=-FUNCTION-SOURCE))
   (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) #'FUNCTION-BYTECODE))
  -(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST #'EQL)) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST #'EQ) #'CL:EQ) ((CL:LABELS ((~G1521 (~G1471) (CL:COND (~G1471 ~G1471) (T (CL:EQ TEST #'==))))) (~G1521 (CL:EQ TEST #'EQL))) #'CL:EQL) ((CL:EQ TEST #'STRING==) #'CL:EQUAL) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) #'MAKE-HASH-TABLE))
  +(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST #'EQL)) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST #'EQ) #'CL:EQ) ((CL:LABELS ((~G1467 (~G1417) (CL:COND (~G1417 ~G1417) (T (CL:EQ TEST #'==))))) (~G1467 (CL:EQ TEST #'EQL))) #'CL:EQL) ((CL:EQ TEST #'STRING==) #'CL:EQUAL) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) #'MAKE-HASH-TABLE))
   (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) #'HASH-TABLE?))
   (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) #'HREF))
   (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) #'=-HREF))
   (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) #'HREMOVE))
  -(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1522 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1522 (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*) #'COPY-HASH-TABLE))
  -(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1523 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1523 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'HASHKEYS))
  +(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1468 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1468 (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*) #'COPY-HASH-TABLE))
  +(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1469 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1469 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'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*) #'SYS-IMAGE-CREATE))
  -(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1524 (~G1473) (CL:COND (~G1473 ~G1473) (T NIL)))) (~G1524 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) #'%START-CORE))
  +(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1470 (~G1419) (CL:COND (~G1419 ~G1419) (T NIL)))) (~G1470 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) #'%START-CORE))
   (CL:DEFVAR *DEFAULT-LISTPROP*)
   (CL:PROGN (CL:DEFUN CPR (X) X NIL) (CL:SETF (CL:GETHASH 'CPR *BUILTIN-ATOMS*) #'CPR))
   (CL:PROGN (CL:DEFUN RPLACP (V X) X V) (CL:SETF (CL:GETHASH 'RPLACP *BUILTIN-ATOMS*) #'RPLACP))
  
positive.code: (CL:PROGN (CL:DEFUN STRING== (A B) (CL:STRING= A B)) (CL:SETF (CL:GETHASH 'STRING== *BUILTIN-ATOMS*) #'STRING==))
  (CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:APPLY #'CL:CONCATENATE 'CL:STRING (CL:MAPCAR (CL:LAMBDA (X) (CL:STRING (CL:COND ((CL:NUMBERP X) (CL:CODE-CHAR X)) (T X)))) X))) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) #'LIST-STRING))
  (CL:DEFVAR *SPECIAL-FORMS*)
  (CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G1547 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X) :BREAK-ON-ERRORS? T)))) (~G1547 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST #'EQ)))))
  (CL:DEFUN SPECIAL-%%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST #'EQ))))))
  (CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G1548 (~G1490) (CL:PROGN (CL:SETQ *MACRO?* #'SPECIAL-%%MACRO?)) (CL:LABELS ((~G1549 (~G1492) (CL:PROGN (CL:SETQ *MACRO?* ~G1490)) ~G1492)) (~G1549 (CL:PROGN (CL:LABELS ((~G1550 (~G1491) (CL:PROGN (CL:SETQ *MACROCALL* #'SPECIAL-%%MACROCALL)) (CL:LABELS ((~G1551 (~G1493) (CL:PROGN (CL:SETQ *MACROCALL* ~G1491)) ~G1493)) (~G1551 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G1550 *MACROCALL*))))))) (~G1548 *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*) #'MAKE-SYMBOL))
  
negative.code: (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* T)
  (CL:SETQ *MACROCALL* NIL)
  (CL:SETQ *MACRO?* NIL)
  (CL:SETQ +CL-FUNCTION-IMPORTS+ (CL:CONS 'CL:ATOM (CL:CONS 'CL:APPLY (CL:CONS 'CL:CONS (CL:CONS 'CL:CAR (CL:CONS 'CL:CDR (CL:CONS 'CL:RPLACA (CL:CONS 'CL:RPLACD (CL:CONS 'CL:LIST (CL:CONS 'CL:LAST (CL:CONS 'CL:COPY-LIST (CL:CONS 'CL:NTHCDR (CL:CONS 'CL:NTH (CL:CONS 'CL:MAPCAR (CL:CONS 'CL:LENGTH (CL:CONS 'CL:MAKE-STRING (CL:CONS 'CL:MOD (CL:CONS 'CL:SQRT (CL:CONS 'CL:SIN (CL:CONS 'CL:COS (CL:CONS 'CL:ATAN (CL:CONS 'CL:EXP (CL:CONS 'CL:ROUND (CL:CONS 'CL:FLOOR (CL:CONS 'CL:AREF (CL:CONS 'CL:CHAR-CODE (CL:CONS 'CL:MAKE-PACKAGE (CL:CONS 'CL:PACKAGE-NAME (CL:CONS 'CL:FIND-PACKAGE (CL:CONS 'CL:PRINT (CL:CONS 'CL:BREAK NIL)))))))))))))))))))))))))))))))
  (cl:in-package :tre)
  (cl:format t "Loading environment...\~%")
  (cl:defvar *new-core?* t)
  