anchor.diff:  (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 ((~G1148 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G1148 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
  +(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G1147 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G1147 (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 ((~G1149 (~G1086) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G1150 (~G1087) (CL:PROGN (CL:SETQ *MACRO?* ~G1086)) ~G1087)) (~G1150 (CL:PROGN (CL:LABELS ((~G1151 (~G1088) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G1152 (~G1089) (CL:PROGN (CL:SETQ *MACROCALL* ~G1088)) ~G1089)) (~G1152 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G1151 *MACROCALL*))))))) (~G1149 *MACRO?*)))
  +(CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G1148 (~G1085) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G1149 (~G1086) (CL:PROGN (CL:SETQ *MACRO?* ~G1085)) ~G1086)) (~G1149 (CL:PROGN (CL:LABELS ((~G1150 (~G1087) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G1151 (~G1088) (CL:PROGN (CL:SETQ *MACROCALL* ~G1087)) ~G1088)) (~G1151 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G1150 *MACROCALL*))))))) (~G1148 *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)))
  
positive.code: (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 ((~G1135 (!) (CL:LABELS ((~G1136 (L) (CL:LABELS ((~G1137 (~G1076) (CL:COND ((INTEGER< ~G1076 0) (ERROR "Negative number of iterations: ~A." ~G1076))) (CL:BLOCK NIL (CL:LABELS ((~G1138 (I) (CL:TAGBODY ~G1077 (CL:COND ((INTEGER== I ~G1076) (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 ~G1077)))) (~G1138 0))))) (~G1137 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1136 NIL)))) (~G1135 (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 ((~G1139 (!) (CL:LABELS ((~G1140 (~G1078) (CL:COND ((INTEGER< ~G1078 0) (ERROR "Negative number of iterations: ~A." ~G1078))) (CL:BLOCK NIL (CL:LABELS ((~G1141 (N) (CL:TAGBODY ~G1079 (CL:COND ((INTEGER== N ~G1078) (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 ~G1079)))) (~G1141 0))))) (~G1140 (INTEGER BITS))))) (~G1139 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1142 (!) (CL:LABELS ((~G1143 (~G1080) (CL:COND ((INTEGER< ~G1080 0) (ERROR "Negative number of iterations: ~A." ~G1080))) (CL:BLOCK NIL (CL:LABELS ((~G1144 (N) (CL:TAGBODY ~G1081 (CL:COND ((INTEGER== N ~G1080) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1081)))) (~G1144 0))))) (~G1143 (INTEGER BITS))))) (~G1142 (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 ((~G1145 (~G1085) (CL:LABELS ((~G1146 (I) (CL:TAGBODY ~G1083 (CL:COND ((NOT ~G1085) (CL:GO ~G1084))) (CL:SETQ I (CL:CAR ~G1085)) (CL:LABELS ((~G1147 (~G1082) (CL:COND (~G1082 ~G1082) (T (CL:RETURN-FROM NIL NIL))))) (~G1147 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1085 (CL:CDR ~G1085)) (CL:GO ~G1083) ~G1084 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1146 NIL)))) (~G1145 (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)))
  
negative.code: (CL:PUSH (CL:CONS (TRE-SYMBOL '%DEFVAR) (CL:CONS '(NAME CL:&OPTIONAL (INIT NIL)) (CL:LAMBDA (NAME INIT) (PRINT-DEFINITION `(%DEFVAR ,NAME)) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',INIT) *VARIABLES*) (CL:DEFVAR ,NAME ,INIT))))) *SPECIAL-FORMS*)
  (CL:PUSH (CL:CONS (TRE-SYMBOL '?) (CL:CONS '(CL:&BODY BODY) (CL:LAMBDA (BODY) (MAKE-? BODY)))) *SPECIAL-FORMS*)
  (CL:SETQ *KEYWORD-PACKAGE* (CL:FIND-PACKAGE "KEYWORD"))
  (CL:SETQ *DEFINITION-PRINTER* (CL:FUNCTION CL:PRINT))
  (CL:SETQ *GENSYM-PREFIX* "~G")
  (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* T)
  (CL:SETQ *STANDARD-INPUT* (MAKE-STANDARD-STREAM))
  (CL:SETQ *MACROEXPAND-BACKQUOTE* (CL:FUNCTION %MACROEXPAND-BACKQUOTE))
  (CL:SETQ *MACROCALL* NIL)
  (CL:SETQ *MACRO?* NIL)
  