anchor.diff:  (CL:DEFUN MAKE-STANDARD-STREAM NIL (CL:BLOCK MAKE-STANDARD-STREAM (CL:BLOCK NIL (MAKE-STREAM :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR NIL))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C NIL)) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF NIL)))))))
   (CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
   (CL:DEFUN MAPCAN (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAN (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION NCONC) (CL:APPLY (CL:FUNCTION CL:MAPCAR) FUNC LISTS)))))
  -(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1369 (L) (CL:LABELS ((~G1370 (S) (CL:BLOCK NIL (CL:LABELS ((~G1371 (I) (CL:TAGBODY ~G94 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G94)))) (~G1371 (-- L)))) S)) (~G1370 NIL)))) (~G1369 (CL:LENGTH X))))))
  -(CL:DEFUN TREE-WALK (I CL:&KEY (ASCENDING NIL) (DONT-ASCEND-IF NIL) (DONT-ASCEND-AFTER-IF NIL)) (CL:BLOCK TREE-WALK (CL:BLOCK NIL (CL:COND ((CL:ATOM I) (FUNCALL ASCENDING I)) (T (CL:PROGN (CL:LABELS ((~G1372 (Y) (CL:LABELS ((~G1373 (A) (CL:PROGN (CL:LABELS ((~G1374 (~G734) (CL:LABELS ((~G1375 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1375 (CL:COND ((CONS? ~G734) (CPR ~G734))))))) (~G1374 I)) (CL:LABELS ((~G1376 (~G733) (RPLACP (CL:CONS A (TREE-WALK (CL:CDR I) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF)) ~G733))) (~G1376 *DEFAULT-LISTPROP*))))) (~G1373 (CL:LABELS ((~G1377 (~G732) (CL:COND (~G732 ~G732) (T (CL:COND ((CL:COND (DONT-ASCEND-AFTER-IF (FUNCALL DONT-ASCEND-AFTER-IF Y))) (FUNCALL ASCENDING Y)) (T (TREE-WALK (CL:COND (ASCENDING (FUNCALL ASCENDING Y)) (T Y)) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF))))))) (~G1377 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1372 (CL:CAR I)))))))))
  +(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1368 (L) (CL:LABELS ((~G1369 (S) (CL:BLOCK NIL (CL:LABELS ((~G1370 (I) (CL:TAGBODY ~G94 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G94)))) (~G1370 (-- L)))) S)) (~G1369 NIL)))) (~G1368 (CL:LENGTH X))))))
  +(CL:DEFUN TREE-WALK (I CL:&KEY (ASCENDING NIL) (DONT-ASCEND-IF NIL) (DONT-ASCEND-AFTER-IF NIL)) (CL:BLOCK TREE-WALK (CL:BLOCK NIL (CL:COND ((CL:ATOM I) (FUNCALL ASCENDING I)) (T (CL:PROGN (CL:LABELS ((~G1371 (Y) (CL:LABELS ((~G1372 (A) (CL:PROGN (CL:LABELS ((~G1373 (~G734) (CL:LABELS ((~G1374 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1374 (CL:COND ((CONS? ~G734) (CPR ~G734))))))) (~G1373 I)) (CL:LABELS ((~G1375 (~G733) (RPLACP (CL:CONS A (TREE-WALK (CL:CDR I) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF)) ~G733))) (~G1375 *DEFAULT-LISTPROP*))))) (~G1372 (CL:LABELS ((~G1376 (~G732) (CL:COND (~G732 ~G732) (T (CL:COND ((CL:COND (DONT-ASCEND-AFTER-IF (FUNCALL DONT-ASCEND-AFTER-IF Y))) (FUNCALL ASCENDING Y)) (T (TREE-WALK (CL:COND (ASCENDING (FUNCALL ASCENDING Y)) (T Y)) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF))))))) (~G1376 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1371 (CL:CAR I)))))))))
   (CL:DEFUN BACKQUOTE? (X) (CL:BLOCK BACKQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'BACKQUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN QUOTE? (X) (CL:BLOCK QUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:QUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN QUASIQUOTE-SPLICE? (X) (CL:BLOCK QUASIQUOTE-SPLICE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE-SPLICE (CL:CAR X)) X)))))))
   (CL:DEFUN QUASIQUOTE? (X) (CL:BLOCK QUASIQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE (CL:CAR X)) X)))))))
   (CL:DEFUN ANY-QUASIQUOTE? (X) (CL:COND ((CONS? X) (CL:COND ((EQ (CL:CAR X) 'QUASIQUOTE) T) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) T)))))
  -(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1378 (~G432) (CL:COND (~G432 ~G432) (T (CL:LABELS ((~G1379 (~G433) (CL:COND (~G433 ~G433) (T (CL:LABELS ((~G1380 (~G434) (CL:COND (~G434 ~G434) (T (CL:LABELS ((~G1381 (~G435) (CL:COND (~G435 ~G435) (T (CL:LABELS ((~G1382 (~G436) (CL:COND (~G436 ~G436) (T (HASH-TABLE? X))))) (~G1382 (ARRAY? X))))))) (~G1381 (STRING? X))))))) (~G1380 (NUMBER? X))))))) (~G1379 (EQ T X))))))) (~G1378 (NOT X))))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1383 (~G179) (CL:LABELS ((~G1384 (S) (CL:LABELS ((~G1385 (~G180) (CL:COND (~G179 ~G180) (T (GET-STREAM-STRING S))))) (~G1385 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1384 (DEFAULT-STREAM ~G179))))) (~G1383 STR)))))
  +(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1377 (~G432) (CL:COND (~G432 ~G432) (T (CL:LABELS ((~G1378 (~G433) (CL:COND (~G433 ~G433) (T (CL:LABELS ((~G1379 (~G434) (CL:COND (~G434 ~G434) (T (CL:LABELS ((~G1380 (~G435) (CL:COND (~G435 ~G435) (T (CL:LABELS ((~G1381 (~G436) (CL:COND (~G436 ~G436) (T (HASH-TABLE? X))))) (~G1381 (ARRAY? X))))))) (~G1380 (STRING? X))))))) (~G1379 (NUMBER? X))))))) (~G1378 (EQ T X))))))) (~G1377 (NOT X))))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1382 (~G179) (CL:LABELS ((~G1383 (S) (CL:LABELS ((~G1384 (~G180) (CL:COND (~G179 ~G180) (T (GET-STREAM-STRING S))))) (~G1384 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1383 (DEFAULT-STREAM ~G179))))) (~G1382 STR)))))
   (CL:DEFUN =-STREAM-PEEKED-CHAR (VAL ARR) (CL:BLOCK =-STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 7)))))
  -(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1386 (~G233) (CL:COND (~G233 ~G233) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1386 (READ-PEEKED-CHAR STR))))))
  +(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1385 (~G233) (CL:COND (~G233 ~G233) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1385 (READ-PEEKED-CHAR STR))))))
   (CL:DEFUN STREAM-PEEKED-CHAR (ARR) (CL:BLOCK STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:AREF ARR 7))))
  -(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1387 (~G315) (CL:LABELS ((~G1388 (~G316) (CL:COND ((NOT (EQ (CL:CAR ~G315) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G315)))) (CL:LABELS ((~G1389 (TOKEN) (CL:LABELS ((~G1390 (~G317) (CL:LABELS ((~G1391 (PKG) (CL:LABELS ((~G1392 (~G318) (CL:LABELS ((~G1393 (SYM) (CL:LABELS ((~G1394 (~G314) (CL:COND ((EQ ~G314 NIL) NIL) ((EQ ~G314 'EOF) NIL) ((EQ ~G314 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G314 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G314 'CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1394 TOKEN)))) (~G1393 (CL:CAR ~G318))))) (~G1392 (CL:LABELS ((~G1395 (~G321) (CL:COND (~G321 ~G321) (T (%ERROR "Not enough VALUES."))))) (~G1395 (CL:CDR ~G317))))))) (~G1391 (CL:CAR ~G317))))) (~G1390 (CL:LABELS ((~G1396 (~G320) (CL:COND (~G320 ~G320) (T (%ERROR "Not enough VALUES."))))) (~G1396 (CL:CDR ~G316))))))) (~G1389 (CL:CAR ~G316))))) (~G1388 (CL:CDR ~G315))))) (~G1387 (READ-TOKEN STR))))))
  -(CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1397 (C) (CL:COND (C (CL:PROGN (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? C) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR))))))))) (~G1397 (PEEK-CHAR STR))))))
  -(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1398 (SL) (CL:LABELS ((~G1399 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1399 (DOT-POSITION SL))))) (~G1398 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1386 (~G315) (CL:LABELS ((~G1387 (~G316) (CL:COND ((NOT (EQ (CL:CAR ~G315) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G315)))) (CL:LABELS ((~G1388 (TOKEN) (CL:LABELS ((~G1389 (~G317) (CL:LABELS ((~G1390 (PKG) (CL:LABELS ((~G1391 (~G318) (CL:LABELS ((~G1392 (SYM) (CL:LABELS ((~G1393 (~G314) (CL:COND ((EQ ~G314 NIL) NIL) ((EQ ~G314 'EOF) NIL) ((EQ ~G314 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G314 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G314 'CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1393 TOKEN)))) (~G1392 (CL:CAR ~G318))))) (~G1391 (CL:LABELS ((~G1394 (~G321) (CL:COND (~G321 ~G321) (T (%ERROR "Not enough VALUES."))))) (~G1394 (CL:CDR ~G317))))))) (~G1390 (CL:CAR ~G317))))) (~G1389 (CL:LABELS ((~G1395 (~G320) (CL:COND (~G320 ~G320) (T (%ERROR "Not enough VALUES."))))) (~G1395 (CL:CDR ~G316))))))) (~G1388 (CL:CAR ~G316))))) (~G1387 (CL:CDR ~G315))))) (~G1386 (READ-TOKEN STR))))))
  +(CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1396 (C) (CL:COND (C (CL:PROGN (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? C) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR))))))))) (~G1396 (PEEK-CHAR STR))))))
  +(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1397 (SL) (CL:LABELS ((~G1398 (P) (CL:COND ((NO-DOT-NOTATION? X) X) ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:CONS '%SLOT-VALUE (CL:CONS (LIST-SYMBOL (SUBSEQ SL 0 P)) (CL:CONS (DOT-EXPAND-CONV (LIST-SYMBOL (SUBSEQ SL (++ P)))) NIL))))))) (~G1398 (DOT-POSITION SL))))) (~G1397 (STRING-LIST (SYMBOL-NAME X)))))))
   (CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
   (CL:DEFUN MAKE-STREAM-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION))) (CL:BLOCK MAKE-STREAM-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR (STREAM-HANDLE _)))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C (STREAM-HANDLE STR))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF (STREAM-HANDLE _))))))))
  -(CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1400 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM-LOCATION ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G156 6)) ~G156)) (~G1400 (MAKE-ARRAY 7))))))
  -(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1401 (~G166) (CL:COND ((EQUAL ~G166 'INPUT) "r") ((EQUAL ~G166 'OUTPUT) "w") ((EQUAL ~G166 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1401 DIRECTION)))))
  +(CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1399 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM-LOCATION ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G156 6)) ~G156)) (~G1399 (MAKE-ARRAY 7))))))
  +(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1400 (~G166) (CL:COND ((EQUAL ~G166 'INPUT) "r") ((EQUAL ~G166 'OUTPUT) "w") ((EQUAL ~G166 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1400 DIRECTION)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN CDRLIST (~G127) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G127))))
  -(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1402 (~G182) (CL:COND (~G182 ~G182) (T (%KEY? X))))) (~G1402 (%REST-OR-%BODY? X))))))
  +(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1401 (~G182) (CL:COND (~G182 ~G182) (T (%KEY? X))))) (~G1401 (%REST-OR-%BODY? X))))))
   (CL:DEFUN %MACROEXPAND-CALL (X) (CL:COND ((CL:APPLY *MACRO?* (CL:LIST X)) (%MACROEXPAND-XLAT X)) (T X)))
   (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  -(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1403 (!) (CL:COND ((CL:LABELS ((~G1404 (~G194) (CL:COND (~G194 ~G194) (T (EQ ! 'ERROR))))) (~G1404 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1403 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
  +(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1402 (!) (CL:COND ((CL:LABELS ((~G1403 (~G194) (CL:COND (~G194 ~G194) (T (EQ ! 'ERROR))))) (~G1403 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1402 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?))))))
   (CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
   (CL:DEFUN SOLE? (X) (CL:BLOCK SOLE? (CL:BLOCK NIL (== 1 (CL:LENGTH X)))))
   (CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:CONS (COPY-HEAD X SIZE) (GROUP (CL:NTHCDR SIZE X) SIZE)))))))
  
positive.code: (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 ((~G1348 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G1348 (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 ((~G1349 (~G1291) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G1350 (~G1293) (CL:PROGN (CL:SETQ *MACRO?* ~G1291)) ~G1293)) (~G1350 (CL:PROGN (CL:LABELS ((~G1351 (~G1292) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G1352 (~G1294) (CL:PROGN (CL:SETQ *MACROCALL* ~G1292)) ~G1294)) (~G1352 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G1351 *MACROCALL*))))))) (~G1349 *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)))
  
negative.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 ((~G1334 (!) (CL:LABELS ((~G1335 (L) (CL:LABELS ((~G1336 (~G1280) (CL:COND ((INTEGER< ~G1280 0) (ERROR "Negative number of iterations: ~A." ~G1280))) (CL:BLOCK NIL (CL:LABELS ((~G1337 (I) (CL:TAGBODY ~G1281 (CL:COND ((INTEGER== I ~G1280) (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 ~G1281)))) (~G1337 0))))) (~G1336 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1335 NIL)))) (~G1334 (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 ((~G1338 (!) (CL:LABELS ((~G1339 (~G1282) (CL:COND ((INTEGER< ~G1282 0) (ERROR "Negative number of iterations: ~A." ~G1282))) (CL:BLOCK NIL (CL:LABELS ((~G1340 (N) (CL:TAGBODY ~G1283 (CL:COND ((INTEGER== N ~G1282) (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 ~G1283)))) (~G1340 0))))) (~G1339 (INTEGER BITS))))) (~G1338 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1341 (!) (CL:LABELS ((~G1342 (~G1284) (CL:COND ((INTEGER< ~G1284 0) (ERROR "Negative number of iterations: ~A." ~G1284))) (CL:BLOCK NIL (CL:LABELS ((~G1343 (N) (CL:TAGBODY ~G1285 (CL:COND ((INTEGER== N ~G1284) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1285)))) (~G1343 0))))) (~G1342 (INTEGER BITS))))) (~G1341 (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 ((~G1344 (~G1289) (CL:LABELS ((~G1345 (I) (CL:TAGBODY ~G1287 (CL:COND ((NOT ~G1289) (CL:GO ~G1288))) (CL:SETQ I (CL:CAR ~G1289)) (CL:LABELS ((~G1346 (~G1286) (CL:COND (~G1286 ~G1286) (T (CL:RETURN-FROM NIL NIL))))) (~G1346 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1289 (CL:CDR ~G1289)) (CL:GO ~G1287) ~G1288 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1345 NIL)))) (~G1344 (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)))
  