anchor.diff:  (CL:DEFVAR *GENSYM-COUNTER*)
   (CL:DEFUN COPY-HEAD (X SIZE) (CL:BLOCK COPY-HEAD (CL:BLOCK NIL (CL:COND ((CL:COND (X (< 0 SIZE))) (CL:CONS (CL:CAR X) (COPY-HEAD (CL:CDR X) (-- SIZE))))))))
   (CL:DEFUN CARLIST (~G126) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G126))))
  -(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1441 (~G189) (CL:LABELS ((~G1442 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1443 (A) (CL:LABELS ((~G1444 (~G191) (CL:LABELS ((~G1445 (K) (CL:LABELS ((~G1446 (ARGDEFS) (CL:LABELS ((~G1447 (KEY-ARGS) (CL:LABELS ((~G1448 (NUM) (CL:LABELS ((~G1449 (NO-STATIC) (CL:LABELS ((~G1450 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~F; In argument expansion for ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL." (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1451 (K) (CL:COND (K (CL:LABELS ((~G1452 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1452 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1451 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1453 (~G187) (CL:COND ((EQ ~G187 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G187 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G187 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1453 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "Too many arguments. Maximum is ~A, but ~A more given." (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1454 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1454 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1455 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G1455 (EXP-MAIN ARGDEFS ALST)))))) (~G1450 NIL)))) (~G1449 NIL)))) (~G1448 0)))) (~G1447 K)))) (~G1446 A)))) (~G1445 (CL:CAR ~G191))))) (~G1444 (CL:LABELS ((~G1456 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1456 (CL:CDR ~G190))))))) (~G1443 (CL:CAR ~G190))))) (~G1442 (CL:CDR ~G189))))) (~G1441 (MAKE-&KEY-ALIST ADEF))))))
  +(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1203 (~G189) (CL:LABELS ((~G1204 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1205 (A) (CL:LABELS ((~G1206 (~G191) (CL:LABELS ((~G1207 (K) (CL:LABELS ((~G1208 (ARGDEFS) (CL:LABELS ((~G1209 (KEY-ARGS) (CL:LABELS ((~G1210 (NUM) (CL:LABELS ((~G1211 (NO-STATIC) (CL:LABELS ((~G1212 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "~L; In argument expansion for ~A: ~A~%" "; Argument definition: ~A~%" "; Given arguments: ~A~%") (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF ALST))) (T 'ERROR))) (EXP-STATIC (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (CL:LIST NUM))))))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-OPTIONAL (DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (CL:RETURN-FROM NIL (ERR "Keyword ~A after &OPTIONAL." (CL:LIST (CL:CAR DEF)))))) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1213 (K) (CL:COND (K (CL:LABELS ((~G1214 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1214 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1213 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (CL:LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1215 (~G187) (CL:COND ((EQ ~G187 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G187 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G187 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1215 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static sublevel argument definition after ~A." (CL:LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((CL:ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for argument ~A." (CL:LIST NUM))))))) (CL:COND (CONCATENATE-SUBLISTS? (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (T (CL:CONS (CL:CONS NIL (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "Too many arguments. Maximum is ~A, but ~A more given." (CL:LIST (CL:LENGTH ARGDEFS) (CL:LENGTH VALS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((NOT (ARGUMENT-NAME? (CL:CAR DEF))) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1216 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1216 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1217 (!) (CL:COND ((EQ ! 'ERROR) !) (T (NCONC ! (NCONC (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:CONS (CL:CAR _) (CL:CONS '%KEY (CL:CDR _))))) KEY-ARGS) REST-ARG)))))) (~G1217 (EXP-MAIN ARGDEFS ALST)))))) (~G1212 NIL)))) (~G1211 NIL)))) (~G1210 0)))) (~G1209 K)))) (~G1208 A)))) (~G1207 (CL:CAR ~G191))))) (~G1206 (CL:LABELS ((~G1218 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1218 (CL:CDR ~G190))))))) (~G1205 (CL:CAR ~G190))))) (~G1204 (CL:CDR ~G189))))) (~G1203 (MAKE-&KEY-ALIST ADEF))))))
   (CL:DEFUN %KEY? (X) (CL:BLOCK %KEY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%KEY (CL:CAR X)) X)))))))
  -(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1457 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1457 (%REST? X))))))
  +(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1219 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1219 (%REST? X))))))
   (CL:DEFUN ++ (X) (NUMBER+ X 1))
   (CL:DEFUN LIST-SYMBOL (X) (CL:BLOCK LIST-SYMBOL (CL:BLOCK NIL (MAKE-SYMBOL (LIST-STRING X)))))
  -(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1458 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1458 START)))) (CL:LABELS ((~G1459 (~G65) (CL:COND ((CONS? ~G65) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G65) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G65) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1459 SEQ))))))))
  -(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1460 (~G112) (CL:LABELS ((~G1461 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1462 (NUM-CDRS) (CL:LABELS ((~G1463 (~G114) (CL:LABELS ((~G1464 (WITHOUT-START) (CL:LABELS ((~G1465 (~G117) (CL:LABELS ((~G1466 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1467 (NUM-CARS) (CL:LABELS ((~G1468 (~G119) (CL:LABELS ((~G1469 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1469 (CL:CAR ~G119))))) (~G1468 (CL:LABELS ((~G1470 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1470 (CL:CDR ~G118))))))) (~G1467 (CL:CAR ~G118))))) (~G1466 (CL:CDR ~G117))))) (~G1465 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1464 (CL:CAR ~G114))))) (~G1463 (CL:LABELS ((~G1471 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1471 (CL:CDR ~G113))))))) (~G1462 (CL:CAR ~G113))))) (~G1461 (CL:CDR ~G112))))) (~G1460 (DOT-EXPAND-HEAD-LENGTH X))))))
  -(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1472 (SL) (CL:LABELS ((~G1473 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1473 (== #\. (CL:CAR SL)))))) (~G1472 (STRING-LIST (SYMBOL-NAME X)))))))
  -(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1474 (SL) (CL:LABELS ((~G1475 (L) (CL:LABELS ((~G1476 (P) (CL:LABELS ((~G1477 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1477 (== 1 L))))) (~G1476 (DOT-POSITION SL))))) (~G1475 (CL:LENGTH SL))))) (~G1474 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1220 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1220 START)))) (CL:LABELS ((~G1221 (~G65) (CL:COND ((CONS? ~G65) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G65) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G65) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1221 SEQ))))))))
  +(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1222 (~G112) (CL:LABELS ((~G1223 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1224 (NUM-CDRS) (CL:LABELS ((~G1225 (~G114) (CL:LABELS ((~G1226 (WITHOUT-START) (CL:LABELS ((~G1227 (~G117) (CL:LABELS ((~G1228 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1229 (NUM-CARS) (CL:LABELS ((~G1230 (~G119) (CL:LABELS ((~G1231 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1231 (CL:CAR ~G119))))) (~G1230 (CL:LABELS ((~G1232 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1232 (CL:CDR ~G118))))))) (~G1229 (CL:CAR ~G118))))) (~G1228 (CL:CDR ~G117))))) (~G1227 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1226 (CL:CAR ~G114))))) (~G1225 (CL:LABELS ((~G1233 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1233 (CL:CDR ~G113))))))) (~G1224 (CL:CAR ~G113))))) (~G1223 (CL:CDR ~G112))))) (~G1222 (DOT-EXPAND-HEAD-LENGTH X))))))
  +(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1234 (SL) (CL:LABELS ((~G1235 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1235 (== #\. (CL:CAR SL)))))) (~G1234 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1236 (SL) (CL:LABELS ((~G1237 (L) (CL:LABELS ((~G1238 (P) (CL:LABELS ((~G1239 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1239 (== 1 L))))) (~G1238 (DOT-POSITION SL))))) (~G1237 (CL:LENGTH SL))))) (~G1236 (STRING-LIST (SYMBOL-NAME X)))))))
   (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION ==)))))
   (CL:DEFUN READ-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-CHAR (CL:BLOCK NIL (%TRACK-LOCATION (STREAM-INPUT-LOCATION STR) (READ-CHAR-0 STR)))))
   (CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((< X 33) (>= X 0))))))
  -(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1478 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1478 (READ-CHAR STR))))))
  -(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1479 (~G276) (CL:COND ((EQ ~G276 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G276 'CHAR) (READ-CHAR STR)) ((EQ ~G276 'NUMBER) (CL:LABELS ((~G1480 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1480 (MAKE-STRING-STREAM)))) ((EQ ~G276 'HEXNUM) (READ-HEX STR)) ((EQ ~G276 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G276 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1481 (~G277) (CL:COND ((EQUAL ~G277 'BRACKET-CLOSE) "Round") ((EQUAL ~G277 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G277 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1481 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1479 TOKEN)))))
  +(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1240 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1240 (READ-CHAR STR))))))
  +(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1241 (~G276) (CL:COND ((EQ ~G276 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G276 'CHAR) (READ-CHAR STR)) ((EQ ~G276 'NUMBER) (CL:LABELS ((~G1242 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1242 (MAKE-STRING-STREAM)))) ((EQ ~G276 'HEXNUM) (READ-HEX STR)) ((EQ ~G276 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G276 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1243 (~G277) (CL:COND ((EQUAL ~G277 'BRACKET-CLOSE) "Round") ((EQUAL ~G277 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G277 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1243 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1241 TOKEN)))))
   (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST TOKEN (READ-EXPR STR)))))
  -(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1482 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1483 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1484 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1485 (~G248) (CL:COND (~G248 ~G248) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1485 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1484 (EQ X 'QUASIQUOTE))))))) (~G1483 (EQ X 'BACKQUOTE))))))) (~G1482 (EQ X 'CL:QUOTE))))))
  -(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1486 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1487 (~G306) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G305)) ~G306)) (~G1487 (CL:PROGN (CL:LABELS ((~G1488 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1489 (~G307) (CL:LABELS ((~G1490 (~G308) (CL:COND ((NOT (EQ (CL:CAR ~G307) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G307)))) (CL:LABELS ((~G1491 (TOKEN) (CL:LABELS ((~G1492 (~G309) (CL:LABELS ((~G1493 (PKG) (CL:LABELS ((~G1494 (~G310) (CL:LABELS ((~G1495 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1495 (CL:CAR ~G310))))) (~G1494 (CL:LABELS ((~G1496 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1496 (CL:CDR ~G309))))))) (~G1493 (CL:CAR ~G309))))) (~G1492 (CL:LABELS ((~G1497 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1497 (CL:CDR ~G308))))))) (~G1491 (CL:CAR ~G308))))) (~G1490 (CL:CDR ~G307))))) (~G1489 (READ-TOKEN STR))))) (T !)))) (~G1488 (READ-CONS STR)))))))) (~G1486 *DEFAULT-LISTPROP*)))))
  -(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1498 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1499 (~G271) (CL:LABELS ((~G1500 (~G272) (CL:COND ((NOT (EQ (CL:CAR ~G271) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G271)))) (CL:LABELS ((~G1501 (PKG) (CL:LABELS ((~G1502 (~G273) (CL:LABELS ((~G1503 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (== #\. (CL:CAR SYM)))))) 'DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) 'NUMBER) (T 'SYMBOL))) (T (CL:LABELS ((~G1504 (~G269) (CL:COND ((CHARACTER== ~G269 #\() 'BRACKET-OPEN) ((CHARACTER== ~G269 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G269 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G269 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G269 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G269 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G269 #\') 'CL:QUOTE) ((CHARACTER== ~G269 #\`) 'BACKQUOTE) ((CHARACTER== ~G269 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G269 #\") 'DBLQUOTE) ((CHARACTER== ~G269 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G269 #\#) (CL:LABELS ((~G1505 (~G270) (CL:COND ((CHARACTER== ~G270 #\\) 'CHAR) ((CHARACTER== ~G270 #\x) 'HEXNUM) ((CHARACTER== ~G270 #\') 'CL:FUNCTION) ((CHARACTER== ~G270 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1505 (READ-CHAR STR)))) ((CHARACTER== ~G269 -1) 'EOF)))) (~G1504 (READ-CHAR STR))))))) PKG SYM))) (~G1503 (CL:CAR ~G273))))) (~G1502 (CL:LABELS ((~G1506 (~G275) (CL:COND (~G275 ~G275) (T (%ERROR "Not enough VALUES."))))) (~G1506 (CL:CDR ~G272))))))) (~G1501 (CL:CAR ~G272))))) (~G1500 (CL:CDR ~G271))))) (~G1499 !))))))) (~G1498 (GET-SYMBOL-AND-PACKAGE STR))))))
  +(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1244 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1245 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1246 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1247 (~G248) (CL:COND (~G248 ~G248) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1247 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1246 (EQ X 'QUASIQUOTE))))))) (~G1245 (EQ X 'BACKQUOTE))))))) (~G1244 (EQ X 'CL:QUOTE))))))
  +(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1248 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1249 (~G306) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G305)) ~G306)) (~G1249 (CL:PROGN (CL:LABELS ((~G1250 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1251 (~G307) (CL:LABELS ((~G1252 (~G308) (CL:COND ((NOT (EQ (CL:CAR ~G307) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G307)))) (CL:LABELS ((~G1253 (TOKEN) (CL:LABELS ((~G1254 (~G309) (CL:LABELS ((~G1255 (PKG) (CL:LABELS ((~G1256 (~G310) (CL:LABELS ((~G1257 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1257 (CL:CAR ~G310))))) (~G1256 (CL:LABELS ((~G1258 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1258 (CL:CDR ~G309))))))) (~G1255 (CL:CAR ~G309))))) (~G1254 (CL:LABELS ((~G1259 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1259 (CL:CDR ~G308))))))) (~G1253 (CL:CAR ~G308))))) (~G1252 (CL:CDR ~G307))))) (~G1251 (READ-TOKEN STR))))) (T !)))) (~G1250 (READ-CONS STR)))))))) (~G1248 *DEFAULT-LISTPROP*)))))
  +(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1260 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1261 (~G271) (CL:LABELS ((~G1262 (~G272) (CL:COND ((NOT (EQ (CL:CAR ~G271) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G271)))) (CL:LABELS ((~G1263 (PKG) (CL:LABELS ((~G1264 (~G273) (CL:LABELS ((~G1265 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (== #\. (CL:CAR SYM)))))) 'DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) 'NUMBER) (T 'SYMBOL))) (T (CL:LABELS ((~G1266 (~G269) (CL:COND ((CHARACTER== ~G269 #\() 'BRACKET-OPEN) ((CHARACTER== ~G269 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G269 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G269 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G269 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G269 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G269 #\') 'CL:QUOTE) ((CHARACTER== ~G269 #\`) 'BACKQUOTE) ((CHARACTER== ~G269 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G269 #\") 'DBLQUOTE) ((CHARACTER== ~G269 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G269 #\#) (CL:LABELS ((~G1267 (~G270) (CL:COND ((CHARACTER== ~G270 #\\) 'CHAR) ((CHARACTER== ~G270 #\x) 'HEXNUM) ((CHARACTER== ~G270 #\') 'CL:FUNCTION) ((CHARACTER== ~G270 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1267 (READ-CHAR STR)))) ((CHARACTER== ~G269 -1) 'EOF)))) (~G1266 (READ-CHAR STR))))))) PKG SYM))) (~G1265 (CL:CAR ~G273))))) (~G1264 (CL:LABELS ((~G1268 (~G275) (CL:COND (~G275 ~G275) (T (%ERROR "Not enough VALUES."))))) (~G1268 (CL:CDR ~G272))))))) (~G1263 (CL:CAR ~G272))))) (~G1262 (CL:CDR ~G271))))) (~G1261 !))))))) (~G1260 (GET-SYMBOL-AND-PACKAGE STR))))))
   (CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
   (CL:DEFUN STREAM-FUN-IN (ARR) (CL:BLOCK STREAM-FUN-IN (CL:BLOCK NIL (CL:AREF ARR 3))))
  -(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1507 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1507 (STREAM-PEEKED-CHAR STR))))))
  -(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1508 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1508 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  -(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1509 (~G177) (CL:LABELS ((~G1510 (S) (CL:LABELS ((~G1511 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1511 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1510 (DEFAULT-STREAM ~G177))))) (~G1509 STR)))))
  -(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1512 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1512 (STREAM-OUTPUT-LOCATION STR))))))
  -(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1513 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1513 X)))))
  +(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1269 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1269 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1270 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1270 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  +(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1271 (~G177) (CL:LABELS ((~G1272 (S) (CL:LABELS ((~G1273 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1273 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1272 (DEFAULT-STREAM ~G177))))) (~G1271 STR)))))
  +(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1274 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1274 (STREAM-OUTPUT-LOCATION STR))))))
  +(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1275 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1275 X)))))
   (CL:DEFUN -- (X) (NUMBER- X 1))
  -(CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1514 (~G157) (CL:PROGN (=-AREF 'STRUCT ~G157 0) (=-AREF 'STREAM ~G157 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G157 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G157 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G157 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G157 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G157 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G157 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G157 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T OUTPUT-LOCATION)) ~G157 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G157 10)) ~G157)) (~G1514 (MAKE-ARRAY 11))))))
  +(CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1276 (~G157) (CL:PROGN (=-AREF 'STRUCT ~G157 0) (=-AREF 'STREAM ~G157 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G157 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G157 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G157 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G157 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G157 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G157 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G157 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T OUTPUT-LOCATION)) ~G157 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G157 10)) ~G157)) (~G1276 (MAKE-ARRAY 11))))))
   (CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
   (CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
   (CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
  -(CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G1515 (~G164) (CL:LABELS ((~G1516 (!) (CL:TAGBODY ~G162 (CL:COND ((NOT ~G164) (CL:GO ~G163))) (CL:SETQ ! (CL:CAR ~G164)) (STREAM-PRINC ! STR) (CL:SETQ ~G164 (CL:CDR ~G164)) (CL:GO ~G162) ~G163 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1516 NIL)))) (~G1515 X)))) ((CL:LABELS ((~G1517 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1517 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (ERROR "Can only print strings and characters. Got ~A." X))))))
  +(CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G1277 (~G164) (CL:LABELS ((~G1278 (!) (CL:TAGBODY ~G162 (CL:COND ((NOT ~G164) (CL:GO ~G163))) (CL:SETQ ! (CL:CAR ~G164)) (STREAM-PRINC ! STR) (CL:SETQ ~G164 (CL:CDR ~G164)) (CL:GO ~G162) ~G163 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1278 NIL)))) (~G1277 X)))) ((CL:LABELS ((~G1279 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1279 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (ERROR "Can only print strings and characters. Got ~A." X))))))
   (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
   (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
   (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION STRING-CONCAT) (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((STRING? _) _) ((CHARACTER? _) (STRING _))))) (QUEUE-LIST X))))))
   (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
   (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
   (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G265 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G265)))))))
  -(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1518 (~G266) (CL:COND (~G266 ~G266) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1518 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1519 (~G267) (CL:COND (~G267 ~G267) (T (== #\. (CL:CAR X)))))) (~G1519 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1520 (~G268) (CL:COND (~G268 ~G268) (T (== #\. _))))) (~G1520 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  -(CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1521 (SYM) (CL:LABELS ((~G1522 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1523 (~G264) (CL:COND (~G264 ~G264) (T T)))) (~G1523 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1522 (PEEK-CHAR STR))))) (~G1521 (GET-SYMBOL STR))))))
  +(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1280 (~G266) (CL:COND (~G266 ~G266) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1280 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1281 (~G267) (CL:COND (~G267 ~G267) (T (== #\. (CL:CAR X)))))) (~G1281 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1282 (~G268) (CL:COND (~G268 ~G268) (T (== #\. _))))) (~G1282 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  +(CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1283 (SYM) (CL:LABELS ((~G1284 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1285 (~G264) (CL:COND (~G264 ~G264) (T T)))) (~G1285 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1284 (PEEK-CHAR STR))))) (~G1283 (GET-SYMBOL STR))))))
   (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS 'SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X))) NIL)) NIL)))) (T (CL:COND ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))))))
  -(CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1524 (LOC) (CL:LABELS ((~G1525 (LINE) (CL:LABELS ((~G1526 (COLUMN) (CL:LABELS ((~G1527 (FILE) (CL:LABELS ((ERR (_) (CL:BLOCK NIL (ERROR "~A in form starting at line ~A, column ~A in file ~A." _ LINE COLUMN FILE))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G1528 (~G278) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1529 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G278)) ~G279)) (~G1529 (CL:PROGN (CL:LABELS ((~G1530 (~G280) (CL:COND ((EQ ~G280 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G280 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G280 '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))))))) (~G1530 TOKEN))))))) (~G1528 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1531 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1532 (~G282) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G281)) ~G282)) (~G1532 (CL:PROGN (CL:LABELS ((~G1533 (!) (CL:COND (! (CL:LABELS ((~G1534 (~G284) (CL:LABELS ((~G1535 (~G285) (CL:COND ((NOT (EQ (CL:CAR ~G284) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G284)))) (CL:LABELS ((~G1536 (TOKEN) (CL:LABELS ((~G1537 (~G286) (CL:LABELS ((~G1538 (PKG) (CL:LABELS ((~G1539 (~G287) (CL:LABELS ((~G1540 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1541 (X) (CL:LABELS ((~G1542 (~G291) (CL:LABELS ((~G1543 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1544 (TOKEN) (CL:LABELS ((~G1545 (~G293) (CL:LABELS ((~G1546 (PKG) (CL:LABELS ((~G1547 (~G294) (CL:LABELS ((~G1548 (SYM) (CL:LABELS ((~G1549 (~G283) (CL:COND (~G283 ~G283) (T (ERR "Only one value allowed after dotted cons."))))) (~G1549 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1548 (CL:CAR ~G294))))) (~G1547 (CL:LABELS ((~G1550 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1550 (CL:CDR ~G293))))))) (~G1546 (CL:CAR ~G293))))) (~G1545 (CL:LABELS ((~G1551 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1551 (CL:CDR ~G292))))))) (~G1544 (CL:CAR ~G292))))) (~G1543 (CL:CDR ~G291))))) (~G1542 (READ-TOKEN STR))))) (~G1541 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1540 (CL:CAR ~G287))))) (~G1539 (CL:LABELS ((~G1552 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1552 (CL:CDR ~G286))))))) (~G1538 (CL:CAR ~G286))))) (~G1537 (CL:LABELS ((~G1553 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1553 (CL:CDR ~G285))))))) (~G1536 (CL:CAR ~G285))))) (~G1535 (CL:CDR ~G284))))) (~G1534 !))) (T (ERR "Closing bracket missing."))))) (~G1533 (READ-TOKEN STR)))))))) (~G1531 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1554 (~G298) (CL:LABELS ((~G1555 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1556 (TOKEN) (CL:LABELS ((~G1557 (~G300) (CL:LABELS ((~G1558 (PKG) (CL:LABELS ((~G1559 (~G301) (CL:LABELS ((~G1560 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1560 (CL:CAR ~G301))))) (~G1559 (CL:LABELS ((~G1561 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1561 (CL:CDR ~G300))))))) (~G1558 (CL:CAR ~G300))))) (~G1557 (CL:LABELS ((~G1562 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1562 (CL:CDR ~G299))))))) (~G1556 (CL:CAR ~G299))))) (~G1555 (CL:CDR ~G298))))) (~G1554 (READ-TOKEN STR)))))) (~G1527 (STREAM-LOCATION-ID LOC))))) (~G1526 (STREAM-LOCATION-COLUMN LOC))))) (~G1525 (STREAM-LOCATION-LINE LOC))))) (~G1524 (STREAM-INPUT-LOCATION STR))))))
  -(CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1563 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1563 (STREAM-INPUT-LOCATION STR))))))
  -(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1564 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1565 (~G250) (CL:COND (~G250 ~G250) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1565 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1564 (EQ X 'BRACKET-CLOSE))))))
  -(CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1566 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (~G1566 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  -(CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1567 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1567 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1568 (~G235) (CL:COND (~G235 ~G235) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1568 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1569 (~G236) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G236)) (~G1569 (REC 0)))))))
  -(CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((== #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1570 (~G237) (CL:COND (~G237 ~G237) (T 0)))) (~G1570 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  -(CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1571 (~G175) (CL:LABELS ((~G1572 (S) (CL:LABELS ((~G1573 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1573 (CL:PROGN (CL:COND ((STRING? X) (STREAM-PRINC X S)) ((CHARACTER? X) (STREAM-PRINC X S)) ((NUMBER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S))) X))))) (~G1572 (DEFAULT-STREAM ~G175))))) (~G1571 STR)))))
  -(CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (STR) (CL:LABELS ((~G1574 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1574 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR) X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
  +(CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1286 (LOC) (CL:LABELS ((~G1287 (LINE) (CL:LABELS ((~G1288 (COLUMN) (CL:LABELS ((~G1289 (FILE) (CL:LABELS ((ERR (_) (CL:BLOCK NIL (ERROR "~A in form starting at line ~A, column ~A in file ~A." _ LINE COLUMN FILE))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G1290 (~G278) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1291 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G278)) ~G279)) (~G1291 (CL:PROGN (CL:LABELS ((~G1292 (~G280) (CL:COND ((EQ ~G280 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G280 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G280 '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))))))) (~G1292 TOKEN))))))) (~G1290 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1293 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1294 (~G282) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G281)) ~G282)) (~G1294 (CL:PROGN (CL:LABELS ((~G1295 (!) (CL:COND (! (CL:LABELS ((~G1296 (~G284) (CL:LABELS ((~G1297 (~G285) (CL:COND ((NOT (EQ (CL:CAR ~G284) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G284)))) (CL:LABELS ((~G1298 (TOKEN) (CL:LABELS ((~G1299 (~G286) (CL:LABELS ((~G1300 (PKG) (CL:LABELS ((~G1301 (~G287) (CL:LABELS ((~G1302 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1303 (X) (CL:LABELS ((~G1304 (~G291) (CL:LABELS ((~G1305 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1306 (TOKEN) (CL:LABELS ((~G1307 (~G293) (CL:LABELS ((~G1308 (PKG) (CL:LABELS ((~G1309 (~G294) (CL:LABELS ((~G1310 (SYM) (CL:LABELS ((~G1311 (~G283) (CL:COND (~G283 ~G283) (T (ERR "Only one value allowed after dotted cons."))))) (~G1311 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1310 (CL:CAR ~G294))))) (~G1309 (CL:LABELS ((~G1312 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1312 (CL:CDR ~G293))))))) (~G1308 (CL:CAR ~G293))))) (~G1307 (CL:LABELS ((~G1313 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1313 (CL:CDR ~G292))))))) (~G1306 (CL:CAR ~G292))))) (~G1305 (CL:CDR ~G291))))) (~G1304 (READ-TOKEN STR))))) (~G1303 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1302 (CL:CAR ~G287))))) (~G1301 (CL:LABELS ((~G1314 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1314 (CL:CDR ~G286))))))) (~G1300 (CL:CAR ~G286))))) (~G1299 (CL:LABELS ((~G1315 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1315 (CL:CDR ~G285))))))) (~G1298 (CL:CAR ~G285))))) (~G1297 (CL:CDR ~G284))))) (~G1296 !))) (T (ERR "Closing bracket missing."))))) (~G1295 (READ-TOKEN STR)))))))) (~G1293 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1316 (~G298) (CL:LABELS ((~G1317 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1318 (TOKEN) (CL:LABELS ((~G1319 (~G300) (CL:LABELS ((~G1320 (PKG) (CL:LABELS ((~G1321 (~G301) (CL:LABELS ((~G1322 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1322 (CL:CAR ~G301))))) (~G1321 (CL:LABELS ((~G1323 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1323 (CL:CDR ~G300))))))) (~G1320 (CL:CAR ~G300))))) (~G1319 (CL:LABELS ((~G1324 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1324 (CL:CDR ~G299))))))) (~G1318 (CL:CAR ~G299))))) (~G1317 (CL:CDR ~G298))))) (~G1316 (READ-TOKEN STR)))))) (~G1289 (STREAM-LOCATION-ID LOC))))) (~G1288 (STREAM-LOCATION-COLUMN LOC))))) (~G1287 (STREAM-LOCATION-LINE LOC))))) (~G1286 (STREAM-INPUT-LOCATION STR))))))
  +(CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1325 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1325 (STREAM-INPUT-LOCATION STR))))))
  +(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1326 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1327 (~G250) (CL:COND (~G250 ~G250) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1327 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1326 (EQ X 'BRACKET-CLOSE))))))
  +(CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1328 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (~G1328 (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND (_ (LIST-STRING _))))) (SPLIT #\. SYM)))))))
  +(CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G1329 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1329 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1330 (~G235) (CL:COND (~G235 ~G235) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1330 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1331 (~G236) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G236)) (~G1331 (REC 0)))))))
  +(CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((== #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1332 (~G237) (CL:COND (~G237 ~G237) (T 0)))) (~G1332 (CL:COND ((PEEK-DOT STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
  +(CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1333 (~G175) (CL:LABELS ((~G1334 (S) (CL:LABELS ((~G1335 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1335 (CL:PROGN (CL:COND ((STRING? X) (STREAM-PRINC X S)) ((CHARACTER? X) (STREAM-PRINC X S)) ((NUMBER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S))) X))))) (~G1334 (DEFAULT-STREAM ~G175))))) (~G1333 STR)))))
  +(CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (STR) (CL:LABELS ((~G1336 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1336 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR) X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
   (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (LIST-STRING (READ-STRING-0 STR)))))
  -(CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1575 (~G13) (CL:LABELS ((~G1576 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1577 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1578 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1578 (> N I))))))) (~G1577 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1576 NIL)))) (~G1575 X))))))
  -(CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1579 (STREAM-LOCATION) (CL:LABELS ((~G1580 (TRACK?) (CL:LABELS ((~G1581 (ID) (CL:LABELS ((~G1582 (LINE) (CL:LABELS ((~G1583 (COLUMN) (CL:LABELS ((~G1584 (TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1585 (~G160) (CL:LABELS ((~G1586 (!) (CL:TAGBODY ~G158 (CL:COND ((NOT ~G160) (CL:GO ~G159))) (CL:SETQ ! (CL:CAR ~G160)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G160 (CL:CDR ~G160)) (CL:GO ~G158) ~G159 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1586 NIL)))) (~G1585 (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)) (~G1584 (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))) (~G1583 (STREAM-LOCATION-COLUMN STREAM-LOCATION))))) (~G1582 (STREAM-LOCATION-LINE STREAM-LOCATION))))) (~G1581 (STREAM-LOCATION-ID STREAM-LOCATION))))) (~G1580 (STREAM-LOCATION-TRACK? STREAM-LOCATION))))) (~G1579 STREAM-LOCATION)))))
  +(CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1337 (~G13) (CL:LABELS ((~G1338 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1339 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1340 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1340 (> N I))))))) (~G1339 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1338 NIL)))) (~G1337 X))))))
  +(CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1341 (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 ((~G1342 (~G160) (CL:LABELS ((~G1343 (!) (CL:TAGBODY ~G158 (CL:COND ((NOT ~G160) (CL:GO ~G159))) (CL:SETQ ! (CL:CAR ~G160)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G160 (CL:CDR ~G160)) (CL:GO ~G158) ~G159 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1343 NIL)))) (~G1342 (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)) (~G1341 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 STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
  -(CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1587 (!) (FIND-IF (CL:LAMBDA (X I) (CL:COND ((FUNCALL TEST X OBJ) (CL:PROGN (CL:SETQ ! I))))) SEQ :START START :END END :FROM-END FROM-END :WITH-INDEX T) !)) (~G1587 NIL)))))
  +(CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1344 (!) (FIND-IF (CL:LAMBDA (X I) (CL:COND ((FUNCALL TEST X OBJ) (CL:PROGN (CL:SETQ ! I))))) SEQ :START START :END END :FROM-END FROM-END :WITH-INDEX T) !)) (~G1344 NIL)))))
   (CL:DEFUN DOT-EXPAND-MAKE-EXPR (WHICH NUM X) (CL:BLOCK DOT-EXPAND-MAKE-EXPR (CL:BLOCK NIL (CL:COND ((< 0 NUM) (CL:CONS WHICH (CL:CONS (DOT-EXPAND-MAKE-EXPR WHICH (-- NUM) X) NIL))) (T X)))))
   (CL:DEFUN DOT-EXPAND-TAIL-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-TAIL-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR (CL:LAST X))) (DOT-EXPAND-TAIL-LENGTH (BUTLAST X) (++ NUM))) (T (VALUES NUM X))))))
   (CL:DEFUN DOT-EXPAND-HEAD-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-HEAD-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
  -(CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1588 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1589 (L) (CL:LABELS ((~G1590 (S) (CL:LABELS ((~G1591 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1592 (X) (CL:TAGBODY ~G63 (CL:COND ((INTEGER== X ~G62) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G63)))) (~G1592 0))))) (~G1591 (INTEGER L))))) (~G1590 (FUNCALL MAKER L))))) (~G1589 (- END START)))))))) (~G1588 (CL:LENGTH SEQ)))))))))
  -(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1593 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1594 (L) (CL:LABELS ((~G1595 (S) (CL:LABELS ((~G1596 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1597 (X) (CL:TAGBODY ~G60 (CL:COND ((INTEGER== X ~G59) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (+ S (STRING (ELT SEQ (+ START X)))))) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G60)))) (~G1597 0))))) (~G1596 (INTEGER L))))) (~G1595 (CL:MAKE-STRING 0))))) (~G1594 (- END START)))))))) (~G1593 (CL:LENGTH SEQ))))))))
  -(CL:DEFUN LIST-SUBSEQ (SEQ START CL:&OPTIONAL (END 999999)) (CL:BLOCK LIST-SUBSEQ (CL:BLOCK NIL (CL:COND ((CL:COND (SEQ (NOT (== START END)))) (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1598 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1598 START)))) (CL:LABELS ((COPY-NUM (LST LEN) (CL:COND (LST (CL:COND ((< 0 LEN) (CL:CONS (CL:CAR LST) (COPY-NUM (CL:CDR LST) (-- LEN))))))))) (COPY-NUM (CL:NTHCDR START SEQ) (- END START)))))))))
  +(CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1345 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1346 (L) (CL:LABELS ((~G1347 (S) (CL:LABELS ((~G1348 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1349 (X) (CL:TAGBODY ~G63 (CL:COND ((INTEGER== X ~G62) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G63)))) (~G1349 0))))) (~G1348 (INTEGER L))))) (~G1347 (FUNCALL MAKER L))))) (~G1346 (- END START)))))))) (~G1345 (CL:LENGTH SEQ)))))))))
  +(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1350 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1351 (L) (CL:LABELS ((~G1352 (S) (CL:LABELS ((~G1353 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1354 (X) (CL:TAGBODY ~G60 (CL:COND ((INTEGER== X ~G59) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (+ S (STRING (ELT SEQ (+ START X)))))) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G60)))) (~G1354 0))))) (~G1353 (INTEGER L))))) (~G1352 (CL:MAKE-STRING 0))))) (~G1351 (- END START)))))))) (~G1350 (CL:LENGTH SEQ))))))))
  +(CL:DEFUN LIST-SUBSEQ (SEQ START CL:&OPTIONAL (END 999999)) (CL:BLOCK LIST-SUBSEQ (CL:BLOCK NIL (CL:COND ((CL:COND (SEQ (NOT (== START END)))) (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1355 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1355 START)))) (CL:LABELS ((COPY-NUM (LST LEN) (CL:COND (LST (CL:COND ((< 0 LEN) (CL:CONS (CL:CAR LST) (COPY-NUM (CL:CDR LST) (-- LEN))))))))) (COPY-NUM (CL:NTHCDR START SEQ) (- END START)))))))))
   (CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
   (CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
   (CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  
positive.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 ((~G1599 (~G184) (CL:COND (~G184 ~G184) (T (CL:LABELS ((~G1600 (~G185) (CL:COND (~G185 ~G185) (T (CL:LABELS ((~G1601 (~G186) (CL:COND (~G186 ~G186) (T (EQ X 'CL:&KEY))))) (~G1601 (EQ X 'CL:&OPTIONAL))))))) (~G1600 (EQ X 'CL:&BODY))))))) (~G1599 (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 ((~G1602 (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 ((~G1603 (!) (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 _)))) (~G1603 (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))))) (~G1602 NIL)))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1604 (!) (CL:BLOCK NIL (CL:LABELS ((~G1605 (~G41) (CL:LABELS ((~G1606 (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 !))))) (~G1606 NIL)))) (~G1605 LST))))) (~G1604 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1607 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1607 (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 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 READ-STRING-0 (STR) (CL:BLOCK READ-STRING-0 (CL:BLOCK NIL (CL:LABELS ((~G1608 (C) (CL:COND ((NOT (== C #\")) (CL:PROGN (CL:CONS (CL:COND ((== C #\\) (READ-CHAR STR)) (T C)) (READ-STRING-0 STR))))))) (~G1608 (READ-CHAR STR))))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1609 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1609 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1610 (~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)) (~G1610 (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 ((~G1611 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1611 (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 ((~G1612 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1612 (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 ((~G1613 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1613 (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 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 ((~G1614 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1615 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1615 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1614 (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 ((~G1616 (~G232) (CL:COND (~G232 ~G232) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1616 (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 GET-SYMBOL (STR) (CL:BLOCK GET-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G1617 (C) (CL:COND (C (CL:PROGN (CL:COND ((NOT (SPECIAL-CHAR? C)) (CL:PROGN (GET-SYMBOL-0 STR))))))))) (~G1617 (PEEK-CHAR STR))))))
  (CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1618 (~G109) (CL:LABELS ((~G1619 (SEQ) (CL:TAGBODY ~G107 (CL:COND ((NOT ~G109) (CL:GO ~G108))) (CL:SETQ SEQ (CL:CAR ~G109)) (CL:LABELS ((~G1620 (~G110) (CL:COND ((INTEGER< ~G110 0) (ERROR "Negative number of iterations: ~A." ~G110))) (CL:BLOCK NIL (CL:LABELS ((~G1621 (!) (CL:TAGBODY ~G111 (CL:COND ((INTEGER== ! ~G110) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1622 (~G106) (CL:COND (~G106 ~G106) (T (CL:RETURN-FROM EVERY NIL))))) (~G1622 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G111)))) (~G1621 0))))) (~G1620 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G109 (CL:CDR ~G109)) (CL:GO ~G107) ~G108 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1619 NIL)))) (~G1618 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1623 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1623 (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 ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  (CL:DEFVAR *MEMORIZED-NUMBERS*)
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G1624 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1624 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (RANGE? X #\0 #\9))))
  (CL:DEFUN GET-SYMBOL-0 (STR) (CL:BLOCK GET-SYMBOL-0 (CL:BLOCK NIL (CL:LABELS ((~G1625 (C) (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR) (GET-SYMBOL-0 STR))) (T (CL:COND ((SYMBOL-CHAR? C) (CL:CONS (CHAR-UPCASE (READ-CHAR STR)) (GET-SYMBOL-0 STR)))))))) (~G1625 (CHAR-UPCASE (PEEK-CHAR STR)))))))
  (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 ((~G1626 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1626 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1627 (~G70) (CL:LABELS ((~G1628 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1629 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1629 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1628 NIL)))) (~G1627 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1630 (~G18) (CL:LABELS ((~G1631 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1632 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1633 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1633 (< N I))))))) (~G1632 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1631 NIL)))) (~G1630 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1634 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1635 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1636 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1637 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G1638 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1639 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G1640 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1641 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1642 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1643 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1644 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1645 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1646 (~G263) (CL:COND (~G263 ~G263) (T (== X #\^))))) (~G1646 (== X #\#))))))) (~G1645 (== X #\"))))))) (~G1644 (== X #\;))))))) (~G1643 (== X #\:))))))) (~G1642 (== X #\,))))))) (~G1641 (== X #\`))))))) (~G1640 (== X #\'))))))) (~G1639 (== X #\}))))))) (~G1638 (== X #\{))))))) (~G1637 (== X #\]))))))) (~G1636 (== X #\[))))))) (~G1635 (== X #\)))))))) (~G1634 (== 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 ((~G1647 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1647 (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 ((~G1648 (E) (CL:LABELS ((~G1649 (S) (CL:COND ((CL:LABELS ((~G1650 (~G103) (CL:COND (~G103 ~G103) (T (CL:COND ((< S E) FROM-END)))))) (~G1650 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1651 (~G104) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G104)))) (~G1651 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1652 (I) (CL:TAGBODY ~G105 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1653 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1653 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G105)))) (~G1652 S))))) (~G1649 (CL:LABELS ((~G1654 (~G102) (CL:COND (~G102 ~G102) (T 0)))) (~G1654 START)))))) (~G1648 (CL:LABELS ((~G1655 (~G101) (CL:COND (~G101 ~G101) (T (-- (CL:LENGTH SEQ)))))) (~G1655 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1656 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1657 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1658 (~G100) (CL:LABELS ((~G1659 (!) (CL:TAGBODY ~G98 (CL:COND ((NOT ~G100) (CL:GO ~G99))) (CL:SETQ ! (CL:CAR ~G100)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G100 (CL:CDR ~G100)) (CL:GO ~G98) ~G99 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1659 NIL)))) (~G1658 !))))) (~G1657 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1660 (~G97) (CL:LABELS ((~G1661 (!) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ ! (CL:CAR ~G97)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1661 NIL)))) (~G1660 !))))))) (~G1656 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1662 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1662 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1663 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1663 (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))))))
  
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 ((~G1132 (!) (CL:LABELS ((~G1133 (L) (CL:LABELS ((~G1134 (~G1073) (CL:COND ((INTEGER< ~G1073 0) (ERROR "Negative number of iterations: ~A." ~G1073))) (CL:BLOCK NIL (CL:LABELS ((~G1135 (I) (CL:TAGBODY ~G1074 (CL:COND ((INTEGER== I ~G1073) (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 ~G1074)))) (~G1135 0))))) (~G1134 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1133 NIL)))) (~G1132 (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 ((~G1136 (!) (CL:LABELS ((~G1137 (~G1075) (CL:COND ((INTEGER< ~G1075 0) (ERROR "Negative number of iterations: ~A." ~G1075))) (CL:BLOCK NIL (CL:LABELS ((~G1138 (N) (CL:TAGBODY ~G1076 (CL:COND ((INTEGER== N ~G1075) (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 ~G1076)))) (~G1138 0))))) (~G1137 (INTEGER BITS))))) (~G1136 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1139 (!) (CL:LABELS ((~G1140 (~G1077) (CL:COND ((INTEGER< ~G1077 0) (ERROR "Negative number of iterations: ~A." ~G1077))) (CL:BLOCK NIL (CL:LABELS ((~G1141 (N) (CL:TAGBODY ~G1078 (CL:COND ((INTEGER== N ~G1077) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1078)))) (~G1141 0))))) (~G1140 (INTEGER BITS))))) (~G1139 (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 ((~G1142 (~G1082) (CL:LABELS ((~G1143 (I) (CL:TAGBODY ~G1080 (CL:COND ((NOT ~G1082) (CL:GO ~G1081))) (CL:SETQ I (CL:CAR ~G1082)) (CL:LABELS ((~G1144 (~G1079) (CL:COND (~G1079 ~G1079) (T (CL:RETURN-FROM NIL NIL))))) (~G1144 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1082 (CL:CDR ~G1082)) (CL:GO ~G1080) ~G1081 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1143 NIL)))) (~G1142 (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)))
  