anchor.diff:  (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:INVOKE-DEBUGGER 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)
  
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:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY #'%> X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) #'>))
  (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 ((~G1480 (!) (CL:LABELS ((~G1481 (L) (CL:LABELS ((~G1482 (~G1426) (CL:COND ((INTEGER< ~G1426 0) (ERROR "Negative number of iterations: ~A."  ~G1426))) (CL:BLOCK NIL (CL:LABELS ((~G1483 (I) (CL:TAGBODY ~G1427 (CL:COND ((INTEGER== I ~G1426) (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 ~G1427)))) (~G1483 0))))) (~G1482 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1481 NIL)))) (~G1480 (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*) #'BIT-AND))
  (CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1484 (!) (CL:LABELS ((~G1485 (~G1428) (CL:COND ((INTEGER< ~G1428 0) (ERROR "Negative number of iterations: ~A."  ~G1428))) (CL:BLOCK NIL (CL:LABELS ((~G1486 (N) (CL:TAGBODY ~G1429 (CL:COND ((INTEGER== N ~G1428) (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 ~G1429)))) (~G1486 0))))) (~G1485 (INTEGER BITS))))) (~G1484 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1487 (!) (CL:LABELS ((~G1488 (~G1430) (CL:COND ((INTEGER< ~G1430 0) (ERROR "Negative number of iterations: ~A."  ~G1430))) (CL:BLOCK NIL (CL:LABELS ((~G1489 (N) (CL:TAGBODY ~G1431 (CL:COND ((INTEGER== N ~G1430) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1431)))) (~G1489 0))))) (~G1488 (INTEGER BITS))))) (~G1487 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) #'<<))
  (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY #'CL:NOT X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) #'NOT))
  (CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1490 (~G1435) (CL:LABELS ((~G1491 (I) (CL:TAGBODY ~G1433 (CL:COND ((NOT ~G1435) (CL:GO ~G1434))) (CL:SETQ I (CL:CAR ~G1435)) (CL:LABELS ((~G1492 (~G1432) (CL:COND (~G1432 ~G1432) (T (CL:RETURN-FROM NIL NIL))))) (~G1492 (FUNCALL PREDICATE  (CL:CAR X) I))) (CL:SETQ ~G1435 (CL:CDR ~G1435)) (CL:GO ~G1433) ~G1434 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1491 NIL)))) (~G1490 (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))))) (T (CL:EQ A B))))
  (CL:PROGN (CL:DEFUN EQ (CL:&REST X) (VARIABLE-COMPARE #'CL:EQ X)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) #'EQ))
  (CL:PROGN (CL:DEFUN EQL (CL:&REST X) (VARIABLE-COMPARE #'TRE-EQL X)) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) #'EQL))
  