anchor.diff:  (CL:DEFUN STREAM-LOCATION-LINE (ARR) (CL:BLOCK STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:AREF ARR 4))))
   (CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
   (CL:DEFUN READ-SYMBOL (STR) (CL:BLOCK READ-SYMBOL (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (F)))))) (CL:COND ((NOT (SPECIAL-CHAR? (SEEK-CHAR STR))) (CL:PROGN (F))))))))
  -(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1591 (~G111) (CL:LABELS ((~G1592 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1593 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "Negative number of iterations: ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1594 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1595 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1595 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1594 0))))) (~G1593 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1592 NIL)))) (~G1591 SEQS))))))
  +(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1591 (~G111) (CL:LABELS ((~G1592 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1593 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "DOTIMES: Number of iterations is negative. It's ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1594 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1595 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1595 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1594 0))))) (~G1593 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1592 NIL)))) (~G1591 SEQS))))))
   (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1596 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1596 (DECIMAL-DIGIT? C))))))))
   (CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
   (CL:DEFUN STREAM-FUN-OUT (ARR) (CL:BLOCK STREAM-FUN-OUT (CL:BLOCK NIL (CL:AREF ARR 4))))
  
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 ((~G1349 (!) (CL:LABELS ((~G1350 (L) (CL:LABELS ((~G1351 (~G1288) (CL:COND ((INTEGER< ~G1288 0) (ERROR "Negative number of iterations: ~A." ~G1288))) (CL:BLOCK NIL (CL:LABELS ((~G1352 (I) (CL:TAGBODY ~G1289 (CL:COND ((INTEGER== I ~G1288) (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 ~G1289)))) (~G1352 0))))) (~G1351 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1350 NIL)))) (~G1349 (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 ((~G1353 (!) (CL:LABELS ((~G1354 (~G1290) (CL:COND ((INTEGER< ~G1290 0) (ERROR "Negative number of iterations: ~A." ~G1290))) (CL:BLOCK NIL (CL:LABELS ((~G1355 (N) (CL:TAGBODY ~G1291 (CL:COND ((INTEGER== N ~G1290) (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 ~G1291)))) (~G1355 0))))) (~G1354 (INTEGER BITS))))) (~G1353 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1356 (!) (CL:LABELS ((~G1357 (~G1292) (CL:COND ((INTEGER< ~G1292 0) (ERROR "Negative number of iterations: ~A." ~G1292))) (CL:BLOCK NIL (CL:LABELS ((~G1358 (N) (CL:TAGBODY ~G1293 (CL:COND ((INTEGER== N ~G1292) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1293)))) (~G1358 0))))) (~G1357 (INTEGER BITS))))) (~G1356 (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 ((~G1359 (~G1297) (CL:LABELS ((~G1360 (I) (CL:TAGBODY ~G1295 (CL:COND ((NOT ~G1297) (CL:GO ~G1296))) (CL:SETQ I (CL:CAR ~G1297)) (CL:LABELS ((~G1361 (~G1294) (CL:COND (~G1294 ~G1294) (T (CL:RETURN-FROM NIL NIL))))) (~G1361 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1297 (CL:CDR ~G1297)) (CL:GO ~G1295) ~G1296 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1360 NIL)))) (~G1359 (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))))
  
negative.code: (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 ((~G1328 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1329 (~G1274) (CL:COND (~G1274 (CL:PROGN (CL:LABELS ((~G1330 (~G1276) (CL:COND ((INTEGER< ~G1276 0) (ERROR "DOTIMES: Number of iterations is negative. It's ~A." ~G1276))) (CL:BLOCK NIL (CL:LABELS ((~G1331 (~G1275) (CL:TAGBODY ~G1277 (CL:COND ((INTEGER== ~G1275 ~G1276) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1332 (I) (%PRINC I !))) (~G1332 (ELT ~G1274 ~G1275))) (CL:SETQ ~G1275 (INTEGER+ 1 ~G1275)) (CL:GO ~G1277)))) (~G1331 0))))) (~G1330 (INTEGER (CL:LENGTH ~G1274))))))))) (~G1329 X))) (T (CL:PRINC X !))))) (~G1328 (CL:LABELS ((~G1333 (~G1273) (CL:COND (~G1273 ~G1273) (T CL:*STANDARD-OUTPUT*)))) (~G1333 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)))
  