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 ((~G1181 (L) (CL:LABELS ((~G1182 (S) (CL:BLOCK NIL (CL:LABELS ((~G1183 (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)))) (~G1183 (-- L)))) S)) (~G1182 NIL)))) (~G1181 (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 ((~G1184 (Y) (CL:LABELS ((~G1185 (A) (CL:PROGN (CL:LABELS ((~G1186 (~G743) (CL:LABELS ((~G1187 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1187 (CL:COND ((CONS? ~G743) (CPR ~G743))))))) (~G1186 I)) (CL:LABELS ((~G1188 (~G742) (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)) ~G742))) (~G1188 *DEFAULT-LISTPROP*))))) (~G1185 (CL:LABELS ((~G1189 (~G741) (CL:COND (~G741 ~G741) (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))))))) (~G1189 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1184 (CL:CAR I)))))))))
  +(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1375 (L) (CL:LABELS ((~G1376 (S) (CL:BLOCK NIL (CL:LABELS ((~G1377 (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)))) (~G1377 (-- L)))) S)) (~G1376 NIL)))) (~G1375 (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 ((~G1378 (Y) (CL:LABELS ((~G1379 (A) (CL:PROGN (CL:LABELS ((~G1380 (~G743) (CL:LABELS ((~G1381 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1381 (CL:COND ((CONS? ~G743) (CPR ~G743))))))) (~G1380 I)) (CL:LABELS ((~G1382 (~G742) (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)) ~G742))) (~G1382 *DEFAULT-LISTPROP*))))) (~G1379 (CL:LABELS ((~G1383 (~G741) (CL:COND (~G741 ~G741) (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))))))) (~G1383 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1378 (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 ((~G1190 (~G441) (CL:COND (~G441 ~G441) (T (CL:LABELS ((~G1191 (~G442) (CL:COND (~G442 ~G442) (T (CL:LABELS ((~G1192 (~G443) (CL:COND (~G443 ~G443) (T (CL:LABELS ((~G1193 (~G444) (CL:COND (~G444 ~G444) (T (CL:LABELS ((~G1194 (~G445) (CL:COND (~G445 ~G445) (T (HASH-TABLE? X))))) (~G1194 (ARRAY? X))))))) (~G1193 (STRING? X))))))) (~G1192 (NUMBER? X))))))) (~G1191 (EQ T X))))))) (~G1190 (NOT X))))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1195 (~G182) (CL:LABELS ((~G1196 (S) (CL:LABELS ((~G1197 (~G183) (CL:COND (~G182 ~G183) (T (GET-STREAM-STRING S))))) (~G1197 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1196 (DEFAULT-STREAM ~G182))))) (~G1195 STR)))))
  +(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1384 (~G441) (CL:COND (~G441 ~G441) (T (CL:LABELS ((~G1385 (~G442) (CL:COND (~G442 ~G442) (T (CL:LABELS ((~G1386 (~G443) (CL:COND (~G443 ~G443) (T (CL:LABELS ((~G1387 (~G444) (CL:COND (~G444 ~G444) (T (CL:LABELS ((~G1388 (~G445) (CL:COND (~G445 ~G445) (T (HASH-TABLE? X))))) (~G1388 (ARRAY? X))))))) (~G1387 (STRING? X))))))) (~G1386 (NUMBER? X))))))) (~G1385 (EQ T X))))))) (~G1384 (NOT X))))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1389 (~G182) (CL:LABELS ((~G1390 (S) (CL:LABELS ((~G1391 (~G183) (CL:COND (~G182 ~G183) (T (GET-STREAM-STRING S))))) (~G1391 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1390 (DEFAULT-STREAM ~G182))))) (~G1389 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 ((~G1198 (~G238) (CL:COND (~G238 ~G238) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1198 (READ-PEEKED-CHAR STR))))))
  +(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1392 (~G239) (CL:COND (~G239 ~G239) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1392 (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 ((~G1199 (~G320) (CL:LABELS ((~G1200 (~G321) (CL:COND ((NOT (EQ (CL:CAR ~G320) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G320)))) (CL:LABELS ((~G1201 (TOKEN) (CL:LABELS ((~G1202 (~G322) (CL:LABELS ((~G1203 (PKG) (CL:LABELS ((~G1204 (~G323) (CL:LABELS ((~G1205 (SYM) (CL:LABELS ((~G1206 (~G319) (CL:COND ((EQ ~G319 NIL) NIL) ((EQ ~G319 'EOF) NIL) ((EQ ~G319 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G319 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G319 '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))))))) (~G1206 TOKEN)))) (~G1205 (CL:CAR ~G323))))) (~G1204 (CL:LABELS ((~G1207 (~G326) (CL:COND (~G326 ~G326) (T (%ERROR "Not enough VALUES."))))) (~G1207 (CL:CDR ~G322))))))) (~G1203 (CL:CAR ~G322))))) (~G1202 (CL:LABELS ((~G1208 (~G325) (CL:COND (~G325 ~G325) (T (%ERROR "Not enough VALUES."))))) (~G1208 (CL:CDR ~G321))))))) (~G1201 (CL:CAR ~G321))))) (~G1200 (CL:CDR ~G320))))) (~G1199 (READ-TOKEN STR))))))
  +(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1393 (~G321) (CL:LABELS ((~G1394 (~G322) (CL:COND ((NOT (EQ (CL:CAR ~G321) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G321)))) (CL:LABELS ((~G1395 (TOKEN) (CL:LABELS ((~G1396 (~G323) (CL:LABELS ((~G1397 (PKG) (CL:LABELS ((~G1398 (~G324) (CL:LABELS ((~G1399 (SYM) (CL:LABELS ((~G1400 (~G320) (CL:COND ((EQ ~G320 NIL) NIL) ((EQ ~G320 'EOF) NIL) ((EQ ~G320 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G320 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G320 '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))))))) (~G1400 TOKEN)))) (~G1399 (CL:CAR ~G324))))) (~G1398 (CL:LABELS ((~G1401 (~G327) (CL:COND (~G327 ~G327) (T (%ERROR "Not enough VALUES."))))) (~G1401 (CL:CDR ~G323))))))) (~G1397 (CL:CAR ~G323))))) (~G1396 (CL:LABELS ((~G1402 (~G326) (CL:COND (~G326 ~G326) (T (%ERROR "Not enough VALUES."))))) (~G1402 (CL:CDR ~G322))))))) (~G1395 (CL:CAR ~G322))))) (~G1394 (CL:CDR ~G321))))) (~G1393 (READ-TOKEN STR))))))
   (CL:DEFUN SEEK-CHAR (STR) (CL:BLOCK SEEK-CHAR (CL:BLOCK NIL (SKIP-SPACES STR) (PEEK-CHAR STR))))
  -(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1209 (SL) (CL:LABELS ((~G1210 (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))))))) (~G1210 (DOT-POSITION SL))))) (~G1209 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1403 (SL) (CL:LABELS ((~G1404 (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))))))) (~G1404 (DOT-POSITION SL))))) (~G1403 (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 ((~G1211 (~G158) (CL:PROGN (=-AREF 'STRUCT ~G158 0) (=-AREF 'STREAM-LOCATION ~G158 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G158 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G158 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G158 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G158 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G158 6)) ~G158)) (~G1211 (MAKE-ARRAY 7))))))
  -(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1212 (~G168) (CL:COND ((EQUAL ~G168 'INPUT) "r") ((EQUAL ~G168 'OUTPUT) "w") ((EQUAL ~G168 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1212 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 ((~G1405 (~G158) (CL:PROGN (=-AREF 'STRUCT ~G158 0) (=-AREF 'STREAM-LOCATION ~G158 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G158 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G158 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G158 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G158 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G158 6)) ~G158)) (~G1405 (MAKE-ARRAY 7))))))
  +(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1406 (~G168) (CL:COND ((EQUAL ~G168 'INPUT) "r") ((EQUAL ~G168 'OUTPUT) "w") ((EQUAL ~G168 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1406 DIRECTION)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN CDRLIST (~G129) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G129))))
  -(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1213 (~G185) (CL:COND (~G185 ~G185) (T (%KEY? X))))) (~G1213 (%REST-OR-%BODY? X))))))
  +(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1407 (~G185) (CL:COND (~G185 ~G185) (T (%KEY? X))))) (~G1407 (%REST-OR-%BODY? 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 ((~G1214 (!) (CL:COND ((CL:LABELS ((~G1215 (~G197) (CL:COND (~G197 ~G197) (T (EQ ! 'ERROR))))) (~G1215 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1214 (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 ((~G1408 (!) (CL:COND ((CL:LABELS ((~G1409 (~G197) (CL:COND (~G197 ~G197) (T (EQ ! 'ERROR))))) (~G1409 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1408 (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: ; tré Common Lisp core, generated by 'makefiles/boot-common.lisp'.
  (declaim #+sbcl(sb-ext:muffle-conditions compiler-note style-warning))
  (DEFPACKAGE "TRE-CORE" (:EXPORT "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "&REST" "&BODY" "&OPTIONAL" "&KEY" "BACKQUOTE" "QUASIQUOTE" "QUASIQUOTE-SPLICE" "SQUARE" "CURLY" "ACCENT-CIRCONFLEX" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK" "CHARACTER>" "INTEGER>" "NUMBER>" "CHARACTER<" "INTEGER<" "NUMBER<" "%CODE-CHAR" "CHARACTER?" "ARRAY?" "STRING?" "FUNCTION?" "SYMBOL?" "CONS?" "NANOTIME" "UNIX-SH-CP" "SH" "=-SYMBOL-FUNCTION" "SYMBOL-PACKAGE" "SYMBOL-FUNCTION" "SYMBOL-VALUE" "SYMBOL-NAME" "MAKE-SYMBOL" "LIST-STRING" "STRING==" "STRING" "STRING-CONCAT" "%SET-ELT" "ELT" "EQL" "EQ" "NOT" "<<" ">>" "BIT-XOR" "BIT-OR" "BIT-AND" ">" "<" "/" "*" "CHARACTER-" "INTEGER-" "NUMBER-" "CHARACTER+" "INTEGER+" "NUMBER+" "%>" "%<" "%/" "%*" "%-" "%+" "CHARACTER==" "INTEGER==" "NUMBER==" "==" "CODE-CHAR" "INTEGER" "NUMBER?" "NANOTIME" "QUIT" "MACROEXPAND" "MACROEXPAND-1" "%%MACRO?" "%%MACROCALL" "MACRO?" "LOAD" "APPEND" "FILTER" "RPLACP" "CPR" "%START-CORE" "SYS-IMAGE-CREATE" "HASHKEYS" "COPY-HASH-TABLE" "HREMOVE" "=-HREF" "HREF" "HASH-TABLE?" "MAKE-HASH-TABLE" "FUNCTION-BYTECODE" "=-FUNCTION-SOURCE" "FUNCTION-SOURCE" "FUNCTION-NATIVE" "FILE-EXISTS?" "UNIX-SH-MKDIR" "%READ-CHAR" "%FCLOSE" "%FOPEN" "%FORCE-OUTPUT" "%PRINC" "EVAL" "%ERROR" "ENV-LOAD" "=-AREF" "MAKE-ARRAY" "BUILTIN?" "%DEFUN-QUIET" "%DEFUN" "%DEFVAR" "%DEFMACRO" "?" "*UNIVERSE*" "*VARIABLES*" "*FUNCTIONS*" "*ENVIRONMENT-PATH*" "*ENVIRONMENT-FILENAMES*" "*MACROEXPAND*" "*QUASIQUOTE-EXPAND*" "*DOT-EXPAND*" "*DEFAULT-LISTPROP*" "*KEYWORD-PACKAGE*" "*POINTER-SIZE*" "*LAUNCHFILE*" "*ASSERT*" "*TARGETS*" "*ENDIANESS*" "*CPU-TYPE*" "*LIBC-PATH*" "*RAND-MAX*" "*EVAL*" "CONS?" "SYMBOL?" "FUNCTION?" "STRING?" "ARRAY?" "CHARACTER?" "%CODE-CHAR" "NUMBER<" "INTEGER<" "CHARACTER<" "NUMBER>" "INTEGER>" "CHARACTER>") (:IMPORT-FROM "CL" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "&REST" "&BODY" "&OPTIONAL" "&KEY" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK"))
  (DEFPACKAGE "TRE" (:USE "TRE-CORE"))
  (CL:IN-PACKAGE :TRE-CORE)
  
negative.code: (CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
  (CL:DEFUN $ (CL:&REST ARGS) (CL:BLOCK $ (CL:BLOCK NIL (MAKE-SYMBOL (CL:APPLY (CL:FUNCTION +) (CL:MAPCAR (CL:FUNCTION STRING) ARGS))))))
  (CL:DEFUN ARGDEF-GET-VALUE (DEFS VALS) (CL:BLOCK ARGDEF-GET-VALUE (CL:BLOCK NIL (CL:COND ((CONS? VALS) (CL:CAR VALS)) ((CONS? (CL:CAR DEFS)) (CADR (CL:CAR DEFS))) (T (CL:CAR DEFS))))))
  (CL:DEFUN ARGUMENT-KEYWORD? (X) (CL:BLOCK ARGUMENT-KEYWORD? (CL:BLOCK NIL (CL:LABELS ((~G1558 (~G187) (CL:COND (~G187 ~G187) (T (CL:LABELS ((~G1559 (~G188) (CL:COND (~G188 ~G188) (T (CL:LABELS ((~G1560 (~G189) (CL:COND (~G189 ~G189) (T (EQ X 'CL:&KEY))))) (~G1560 (EQ X 'CL:&OPTIONAL))))))) (~G1559 (EQ X 'CL:&BODY))))))) (~G1558 (EQ X 'CL:&REST))))))
  (CL:DEFUN ARGDEF-GET-NAME (X) (CL:BLOCK ARGDEF-GET-NAME (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:CAR X)) (T X)))))
  (CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G1561 (KEYS) (CL:LABELS ((MAKE-&KEY-DESCR (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR _)) (COPY-DEF-UNTIL-&KEY _)) (T (CL:LABELS ((~G1562 (!) (CL:PROGN (CL:SETQ KEYS (CL:CONS (CL:COND ((CONS? !) (CL:CONS (CL:CAR !) (CL:CAR (CL:CDR !)))) (T (CL:CONS ! !))) KEYS))) (MAKE-&KEY-DESCR (CL:CDR _)))) (~G1562 (CL:CAR _)))))))))) (COPY-DEF-UNTIL-&KEY (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((EQ 'CL:&KEY (CL:CAR _)) (MAKE-&KEY-DESCR (CL:CDR _))) (T (CL:CONS (CL:CAR _) (COPY-DEF-UNTIL-&KEY (CL:CDR _))))))))))) (VALUES (COPY-DEF-UNTIL-&KEY DEF) (REVERSE KEYS))))) (~G1561 NIL)))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1563 (!) (CL:BLOCK NIL (CL:LABELS ((~G1564 (~G41) (CL:LABELS ((~G1565 (I) (CL:TAGBODY ~G39 (CL:COND ((NOT ~G41) (CL:GO ~G40))) (CL:SETQ I (CL:CAR ~G41)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G41 (CL:CDR ~G41)) (CL:GO ~G39) ~G40 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G1565 NIL)))) (~G1564 LST))))) (~G1563 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1566 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1566 (CL:CAR LSTS)))))))))
  (CL:DEFUN =-ELT (VAL SEQ IDX) (CL:BLOCK =-ELT (CL:BLOCK NIL (%SET-ELT VAL SEQ IDX))))
  (CL:DEFUN FIND-IF (PRED SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (WITH-INDEX NIL)) (CL:BLOCK FIND-IF (CL:BLOCK NIL (CL:COND ((NOT (CL:ATOM SEQ) START END) (%FIND-IF-LIST PRED SEQ FROM-END WITH-INDEX)) (T (%FIND-IF-SEQUENCE PRED SEQ START END FROM-END WITH-INDEX))))))
  (CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1567 (~G13) (CL:LABELS ((~G1568 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1569 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1570 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1570 (> N I))))))) (~G1569 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1568 NIL)))) (~G1567 X))))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1571 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1571 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1572 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G1572 (CL:CAR (CL:CDR X)))))))
  (CL:DEFUN ENQUEUE-LIST (X VALS) (CL:BLOCK ENQUEUE-LIST (CL:BLOCK NIL (CL:RPLACD X (NCONC (CL:CDR X) VALS)) (CL:RPLACA X (CL:LAST VALS)))))
  (CL:DEFUN PRINC-NUMBER (X STR) (CL:BLOCK PRINC-NUMBER (CL:BLOCK NIL (CL:COND ((< X 0) (PRINC #\- STR))) (STREAM-PRINC (INTEGER-CHARS X) STR) (CL:LABELS ((~G1573 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1573 (CL:MOD X 1))))))
  (CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1574 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1574 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G1575 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1575 (PEEK-CHAR STR))))))
  (CL:DEFUN READ-INTEGER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-INTEGER (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (INTEGER (READ-INTEGER-0 STR 0)))))))
  (CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:COND ((> X 32) (NOT (SPECIAL-CHAR? X)))))))))
  (CL:DEFUN - (CL:&REST X) (CL:APPLY (CL:FUNCTION NUMBER-) X))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1576 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1577 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1577 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1576 (DIGIT-CHAR? X))))))
  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CHARACTER+ C (CHARACTER- #\A #\a))) (T C)))))
  (CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (GENERIC-SPLIT OBJ SEQ :TEST TEST :INCLUDE? INCLUDE?))))
  (CL:DEFUN MEMORIZED-NUMBER (X) (CL:BLOCK MEMORIZED-NUMBER (CL:BLOCK NIL (CL:LABELS ((~G1578 (~G238) (CL:COND (~G238 ~G238) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1578 (HREF *MEMORIZED-NUMBERS* X))))))
  (CL:DEFUN STREAM-LOCATION-ID (ARR) (CL:BLOCK STREAM-LOCATION-ID (CL:BLOCK NIL (CL:AREF ARR 3))))
  (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 ((~G1579 (~G111) (CL:LABELS ((~G1580 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1581 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "Negative number of iterations: ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1582 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1583 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1583 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1582 0))))) (~G1581 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1580 NIL)))) (~G1579 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1584 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1584 (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))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1585 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1586 (~G162) (CL:LABELS ((~G1587 (!) (CL:TAGBODY ~G160 (CL:COND ((NOT ~G162) (CL:GO ~G161))) (CL:SETQ ! (CL:CAR ~G162)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G162 (CL:CDR ~G162)) (CL:GO ~G160) ~G161 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1587 NIL)))) (~G1586 (STRING-LIST X))))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 X) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 STREAM-LOCATION)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE STREAM-LOCATION) 1) STREAM-LOCATION)))) (T (CL:COND ((== 9 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G1585 STREAM-LOCATION (STREAM-LOCATION-TRACK? STREAM-LOCATION) (STREAM-LOCATION-ID STREAM-LOCATION) (STREAM-LOCATION-LINE STREAM-LOCATION) (STREAM-LOCATION-COLUMN STREAM-LOCATION) (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))))
  (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  (CL:DEFVAR *MEMORIZED-NUMBERS*)
  (CL:DEFUN NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (++ (* SIZE (++ (INTEGER (/ (-- COLUMN) SIZE))))))))
  (CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN =-STREAM-LOCATION-COLUMN (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN STREAM-LOCATION-TABSIZE (ARR) (CL:BLOCK STREAM-LOCATION-TABSIZE (CL:BLOCK NIL (CL:AREF ARR 6))))
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G1588 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1588 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X #\0 #\9))))
  (CL:DEFUN GENERIC-SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK GENERIC-SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G1589 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1589 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1590 (~G70) (CL:LABELS ((~G1591 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1592 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1592 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1591 NIL)))) (~G1590 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1593 (~G18) (CL:LABELS ((~G1594 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1595 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1596 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1596 (< N I))))))) (~G1595 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1594 NIL)))) (~G1593 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1597 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1598 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1599 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1600 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1601 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1602 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1603 (~G263) (CL:COND (~G263 ~G263) (T (CL:LABELS ((~G1604 (~G264) (CL:COND (~G264 ~G264) (T (CL:LABELS ((~G1605 (~G265) (CL:COND (~G265 ~G265) (T (CL:LABELS ((~G1606 (~G266) (CL:COND (~G266 ~G266) (T (CL:LABELS ((~G1607 (~G267) (CL:COND (~G267 ~G267) (T (CL:LABELS ((~G1608 (~G268) (CL:COND (~G268 ~G268) (T (CL:LABELS ((~G1609 (~G269) (CL:COND (~G269 ~G269) (T (== X #\^))))) (~G1609 (== X #\#))))))) (~G1608 (== X #\"))))))) (~G1607 (== X #\;))))))) (~G1606 (== X #\:))))))) (~G1605 (== X #\,))))))) (~G1604 (== X #\`))))))) (~G1603 (== X #\'))))))) (~G1602 (== X #\}))))))) (~G1601 (== X #\{))))))) (~G1600 (== X #\]))))))) (~G1599 (== X #\[))))))) (~G1598 (== X #\)))))))) (~G1597 (== X #\())))))
  (CL:DEFUN READ-INTEGER-0 (STR V) (CL:BLOCK READ-INTEGER-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-INTEGER-0 STR (+ (* V 10) (DIGIT-NUMBER (READ-CHAR STR))))) (T V)))))
  (CL:DEFUN PEEK-DIGIT (STR) (CL:BLOCK PEEK-DIGIT (CL:BLOCK NIL (CL:LABELS ((~G1610 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1610 (PEEK-CHAR STR))))))
  (CL:DEFUN READ-DECIMAL-PLACES-0 (STR V S) (CL:BLOCK READ-DECIMAL-PLACES-0 (CL:BLOCK NIL (CL:COND ((PEEK-DIGIT STR) (READ-DECIMAL-PLACES-0 STR (+ V (* S (DIGIT-NUMBER (READ-CHAR STR)))) (/ S 10))) (T V)))))
  (CL:DEFUN FRACTION-CHARS (X) (CL:BLOCK FRACTION-CHARS (CL:BLOCK NIL (FRACTION-CHARS-0 (CL:MOD (ABS X) 1)))))
  (CL:DEFUN INTEGER-CHARS (X) (CL:BLOCK INTEGER-CHARS (CL:BLOCK NIL (REVERSE (INTEGER-CHARS-0 (INTEGER (ABS X)))))))
  (CL:DEFUN %FIND-IF-SEQUENCE (PRED SEQ START END FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-SEQUENCE (CL:BLOCK NIL (CL:COND (SEQ (CL:COND ((< 0 (CL:LENGTH SEQ)) (CL:LABELS ((~G1611 (E) (CL:LABELS ((~G1612 (S) (CL:COND ((CL:LABELS ((~G1613 (~G105) (CL:COND (~G105 ~G105) (T (CL:COND ((< S E) FROM-END)))))) (~G1613 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1614 (~G106) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G106)))) (~G1614 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1615 (I) (CL:TAGBODY ~G107 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1616 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1616 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G107)))) (~G1615 S))))) (~G1612 (CL:LABELS ((~G1617 (~G104) (CL:COND (~G104 ~G104) (T 0)))) (~G1617 START)))))) (~G1611 (CL:LABELS ((~G1618 (~G103) (CL:COND (~G103 ~G103) (T (-- (CL:LENGTH SEQ)))))) (~G1618 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1619 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1620 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1621 (~G102) (CL:LABELS ((~G1622 (!) (CL:TAGBODY ~G100 (CL:COND ((NOT ~G102) (CL:GO ~G101))) (CL:SETQ ! (CL:CAR ~G102)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G102 (CL:CDR ~G102)) (CL:GO ~G100) ~G101 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1622 NIL)))) (~G1621 !))))) (~G1620 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1623 (~G99) (CL:LABELS ((~G1624 (!) (CL:TAGBODY ~G97 (CL:COND ((NOT ~G99) (CL:GO ~G98))) (CL:SETQ ! (CL:CAR ~G99)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G99 (CL:CDR ~G99)) (CL:GO ~G97) ~G98 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1624 NIL)))) (~G1623 !))))))) (~G1619 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1625 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1625 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1626 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1626 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- X #\0))))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  