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: (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 ((~G1363 (~G187) (CL:COND (~G187 ~G187) (T (CL:LABELS ((~G1364 (~G188) (CL:COND (~G188 ~G188) (T (CL:LABELS ((~G1365 (~G189) (CL:COND (~G189 ~G189) (T (EQ X 'CL:&KEY))))) (~G1365 (EQ X 'CL:&OPTIONAL))))))) (~G1364 (EQ X 'CL:&BODY))))))) (~G1363 (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 ((~G1366 (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 ((~G1367 (!) (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 _)))) (~G1367 (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))))) (~G1366 NIL)))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1368 (!) (CL:BLOCK NIL (CL:LABELS ((~G1369 (~G41) (CL:LABELS ((~G1370 (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 !))))) (~G1370 NIL)))) (~G1369 LST))))) (~G1368 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G1371 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G1371 (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 ((~G1372 (~G13) (CL:LABELS ((~G1373 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1374 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1375 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1375 (> N I))))))) (~G1374 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1373 NIL)))) (~G1372 X))))))
  (CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1376 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1376 (CL:CAR X))) VALS))) VALS)))
  (CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G1377 (~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)) (~G1377 (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 ((~G1378 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1378 (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 ((~G1379 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G1379 (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 ((~G1380 (!) (CL:COND (! (CL:PROGN (== #\. !)))))) (~G1380 (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 ((~G1381 (~G84) (CL:COND (~G84 ~G84) (T (CL:LABELS ((~G1382 (~G85) (CL:COND (~G85 ~G85) (T (CL:COND ((>= X #\a) (<= X #\f))))))) (~G1382 (CL:COND ((>= X #\A) (<= X #\F))))))))) (~G1381 (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 ((~G1383 (~G237) (CL:COND (~G237 ~G237) (T (CL:PROGN (=-HREF X *MEMORIZED-NUMBERS* X)))))) (~G1383 (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 ((~G1384 (~G111) (CL:LABELS ((~G1385 (SEQ) (CL:TAGBODY ~G109 (CL:COND ((NOT ~G111) (CL:GO ~G110))) (CL:SETQ SEQ (CL:CAR ~G111)) (CL:LABELS ((~G1386 (~G112) (CL:COND ((INTEGER< ~G112 0) (ERROR "Negative number of iterations: ~A." ~G112))) (CL:BLOCK NIL (CL:LABELS ((~G1387 (!) (CL:TAGBODY ~G113 (CL:COND ((INTEGER== ! ~G112) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G1388 (~G108) (CL:COND (~G108 ~G108) (T (CL:RETURN-FROM EVERY NIL))))) (~G1388 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G113)))) (~G1387 0))))) (~G1386 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G111 (CL:CDR ~G111)) (CL:GO ~G109) ~G110 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1385 NIL)))) (~G1384 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G1389 (~G83) (CL:COND (~G83 ~G83) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G1389 (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 ((~G1390 (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 ((~G1391 (~G162) (CL:LABELS ((~G1392 (!) (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))))) (~G1392 NIL)))) (~G1391 (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)) (~G1390 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 ((~G1393 (~G82) (CL:COND (~G82 ~G82) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G1393 (%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 ((~G1394 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G1394 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G66) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1395 (~G70) (CL:LABELS ((~G1396 (C) (CL:TAGBODY ~G68 (CL:COND ((NOT ~G70) (CL:GO ~G69))) (CL:SETQ C (CL:CAR ~G70)) (CL:LABELS ((~G1397 (~G67) (CL:COND (~G67 ~G67) (T (CL:RETURN-FROM NIL NIL))))) (~G1397 (RANGE? C #\a #\z))) (CL:SETQ ~G70 (CL:CDR ~G70)) (CL:GO ~G68) ~G69 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1396 NIL)))) (~G1395 ~G66))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1398 (~G18) (CL:LABELS ((~G1399 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1400 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1401 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1401 (< N I))))))) (~G1400 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1399 NIL)))) (~G1398 X))))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G1402 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G1403 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G1404 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G1405 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G1406 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G1407 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G1408 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G1409 (~G263) (CL:COND (~G263 ~G263) (T (CL:LABELS ((~G1410 (~G264) (CL:COND (~G264 ~G264) (T (CL:LABELS ((~G1411 (~G265) (CL:COND (~G265 ~G265) (T (CL:LABELS ((~G1412 (~G266) (CL:COND (~G266 ~G266) (T (CL:LABELS ((~G1413 (~G267) (CL:COND (~G267 ~G267) (T (CL:LABELS ((~G1414 (~G268) (CL:COND (~G268 ~G268) (T (== X #\^))))) (~G1414 (== X #\#))))))) (~G1413 (== X #\"))))))) (~G1412 (== X #\;))))))) (~G1411 (== X #\:))))))) (~G1410 (== X #\,))))))) (~G1409 (== X #\`))))))) (~G1408 (== X #\'))))))) (~G1407 (== X #\}))))))) (~G1406 (== X #\{))))))) (~G1405 (== X #\]))))))) (~G1404 (== X #\[))))))) (~G1403 (== X #\)))))))) (~G1402 (== 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 ((~G1415 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G1415 (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 ((~G1416 (E) (CL:LABELS ((~G1417 (S) (CL:COND ((CL:LABELS ((~G1418 (~G105) (CL:COND (~G105 ~G105) (T (CL:COND ((< S E) FROM-END)))))) (~G1418 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G1419 (~G106) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G106)))) (~G1419 S)))) (CL:BLOCK NIL (CL:LABELS ((~G1420 (I) (CL:TAGBODY ~G107 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1421 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G1421 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G107)))) (~G1420 S))))) (~G1417 (CL:LABELS ((~G1422 (~G104) (CL:COND (~G104 ~G104) (T 0)))) (~G1422 START)))))) (~G1416 (CL:LABELS ((~G1423 (~G103) (CL:COND (~G103 ~G103) (T (-- (CL:LENGTH SEQ)))))) (~G1423 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G1424 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G1425 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G1426 (~G102) (CL:LABELS ((~G1427 (!) (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))))) (~G1427 NIL)))) (~G1426 !))))) (~G1425 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G1428 (~G99) (CL:LABELS ((~G1429 (!) (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))))) (~G1429 NIL)))) (~G1428 !))))))) (~G1424 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1430 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1430 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1431 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1431 (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: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 (~G128) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G128))))
  (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 ((~G1410 (~G192) (CL:LABELS ((~G1411 (~G193) (CL:COND ((NOT (EQ (CL:CAR ~G192) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G192)))) (CL:LABELS ((~G1412 (A) (CL:LABELS ((~G1413 (~G194) (CL:LABELS ((~G1414 (K) (CL:LABELS ((~G1415 (ARGDEFS) (CL:LABELS ((~G1416 (KEY-ARGS) (CL:LABELS ((~G1417 (NUM) (CL:LABELS ((~G1418 (NO-STATIC) (CL:LABELS ((~G1419 (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 ((~G1420 (K) (CL:COND (K (CL:LABELS ((~G1421 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1421 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1420 (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 ((~G1422 (~G190) (CL:COND ((EQ ~G190 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G190 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G190 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1422 (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 ((~G1423 (~G191) (CL:COND (~G191 ~G191) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1423 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1424 (!) (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)))))) (~G1424 (EXP-MAIN ARGDEFS ALST)))))) (~G1419 NIL)))) (~G1418 NIL)))) (~G1417 0)))) (~G1416 K)))) (~G1415 A)))) (~G1414 (CL:CAR ~G194))))) (~G1413 (CL:LABELS ((~G1425 (~G196) (CL:COND (~G196 ~G196) (T (%ERROR "Not enough VALUES."))))) (~G1425 (CL:CDR ~G193))))))) (~G1412 (CL:CAR ~G193))))) (~G1411 (CL:CDR ~G192))))) (~G1410 (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 ((~G1426 (~G184) (CL:COND (~G184 ~G184) (T (%BODY? X))))) (~G1426 (%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 ((~G1427 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1427 START)))) (CL:LABELS ((~G1428 (~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))))) (~G1428 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1429 (~G114) (CL:LABELS ((~G1430 (~G115) (CL:COND ((NOT (EQ (CL:CAR ~G114) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G114)))) (CL:LABELS ((~G1431 (NUM-CDRS) (CL:LABELS ((~G1432 (~G116) (CL:LABELS ((~G1433 (WITHOUT-START) (CL:LABELS ((~G1434 (~G119) (CL:LABELS ((~G1435 (~G120) (CL:COND ((NOT (EQ (CL:CAR ~G119) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G119)))) (CL:LABELS ((~G1436 (NUM-CARS) (CL:LABELS ((~G1437 (~G121) (CL:LABELS ((~G1438 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1438 (CL:CAR ~G121))))) (~G1437 (CL:LABELS ((~G1439 (~G123) (CL:COND (~G123 ~G123) (T (%ERROR "Not enough VALUES."))))) (~G1439 (CL:CDR ~G120))))))) (~G1436 (CL:CAR ~G120))))) (~G1435 (CL:CDR ~G119))))) (~G1434 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1433 (CL:CAR ~G116))))) (~G1432 (CL:LABELS ((~G1440 (~G118) (CL:COND (~G118 ~G118) (T (%ERROR "Not enough VALUES."))))) (~G1440 (CL:CDR ~G115))))))) (~G1431 (CL:CAR ~G115))))) (~G1430 (CL:CDR ~G114))))) (~G1429 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1441 (SL) (CL:LABELS ((~G1442 (~G125) (CL:COND (~G125 ~G125) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1442 (== #\. (CL:CAR SL)))))) (~G1441 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1443 (SL) (CL:LABELS ((~G1444 (L) (CL:LABELS ((~G1445 (P) (CL:LABELS ((~G1446 (~G124) (CL:COND (~G124 ~G124) (T (NOT P))))) (~G1446 (== 1 L))))) (~G1445 (DOT-POSITION SL))))) (~G1444 (CL:LENGTH SL))))) (~G1443 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION ==)))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((SEMICOLON? (PEEK-CHAR STR)) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR)))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1447 (~G282) (CL:COND ((EQ ~G282 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G282 'CHAR) (READ-CHAR STR)) ((EQ ~G282 'NUMBER) (CL:LABELS ((~G1448 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1448 (MAKE-STRING-STREAM)))) ((EQ ~G282 'HEXNUM) (READ-HEX STR)) ((EQ ~G282 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G282 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1449 (~G283) (CL:COND ((EQUAL ~G283 'BRACKET-CLOSE) "Round") ((EQUAL ~G283 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G283 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1449 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1447 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 ((~G1450 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G1451 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G1452 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G1453 (~G254) (CL:COND (~G254 ~G254) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1453 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1452 (EQ X 'QUASIQUOTE))))))) (~G1451 (EQ X 'BACKQUOTE))))))) (~G1450 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1454 (~G311) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1455 (~G312) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G311)) ~G312)) (~G1455 (CL:PROGN (CL:LABELS ((~G1456 (!) (CL:COND ((CL:LABELS ((~G1457 (!) (CL:COND (! (== #\. !))))) (~G1457 (PEEK-CHAR STR))) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1458 (~G313) (CL:LABELS ((~G1459 (~G314) (CL:COND ((NOT (EQ (CL:CAR ~G313) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G313)))) (CL:LABELS ((~G1460 (TOKEN) (CL:LABELS ((~G1461 (~G315) (CL:LABELS ((~G1462 (PKG) (CL:LABELS ((~G1463 (~G316) (CL:LABELS ((~G1464 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1464 (CL:CAR ~G316))))) (~G1463 (CL:LABELS ((~G1465 (~G319) (CL:COND (~G319 ~G319) (T (%ERROR "Not enough VALUES."))))) (~G1465 (CL:CDR ~G315))))))) (~G1462 (CL:CAR ~G315))))) (~G1461 (CL:LABELS ((~G1466 (~G318) (CL:COND (~G318 ~G318) (T (%ERROR "Not enough VALUES."))))) (~G1466 (CL:CDR ~G314))))))) (~G1460 (CL:CAR ~G314))))) (~G1459 (CL:CDR ~G313))))) (~G1458 (READ-TOKEN STR))))) (T !)))) (~G1456 (READ-CONS STR)))))))) (~G1454 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1467 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1468 (~G277) (CL:LABELS ((~G1469 (~G278) (CL:COND ((NOT (EQ (CL:CAR ~G277) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G277)))) (CL:LABELS ((~G1470 (PKG) (CL:LABELS ((~G1471 (~G279) (CL:LABELS ((~G1472 (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 ((~G1473 (~G275) (CL:COND ((CHARACTER== ~G275 #\() 'BRACKET-OPEN) ((CHARACTER== ~G275 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G275 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G275 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G275 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G275 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G275 #\') 'CL:QUOTE) ((CHARACTER== ~G275 #\`) 'BACKQUOTE) ((CHARACTER== ~G275 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G275 #\") 'DBLQUOTE) ((CHARACTER== ~G275 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G275 #\#) (CL:LABELS ((~G1474 (~G276) (CL:COND ((CHARACTER== ~G276 #\\) 'CHAR) ((CHARACTER== ~G276 #\x) 'HEXNUM) ((CHARACTER== ~G276 #\') 'CL:FUNCTION) ((CHARACTER== ~G276 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1474 (READ-CHAR STR)))) ((CHARACTER== ~G275 -1) 'EOF)))) (~G1473 (READ-CHAR STR))))))) PKG SYM))) (~G1472 (CL:CAR ~G279))))) (~G1471 (CL:LABELS ((~G1475 (~G281) (CL:COND (~G281 ~G281) (T (%ERROR "Not enough VALUES."))))) (~G1475 (CL:CDR ~G278))))))) (~G1470 (CL:CAR ~G278))))) (~G1469 (CL:CDR ~G277))))) (~G1468 !))))))) (~G1467 (READ-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 ((~G1476 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1476 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1477 (~G169) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G169)) (~G1477 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1478 (~G180) (CL:LABELS ((~G1479 (S) (CL:LABELS ((~G1480 (~G181) (CL:COND (~G180 ~G181) (T (GET-STREAM-STRING S))))) (~G1480 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1479 (DEFAULT-STREAM ~G180))))) (~G1478 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1481 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1481 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1482 (~G167) (CL:COND ((EQ ~G167 NIL) (MAKE-STRING-STREAM)) ((EQ ~G167 T) *STANDARD-OUTPUT*) (T X)))) (~G1482 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 ((~G1483 (~G159) (CL:PROGN (=-AREF 'STRUCT ~G159 0) (=-AREF 'STREAM ~G159 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G159 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G159 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G159 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G159 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G159 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G159 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G159 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T OUTPUT-LOCATION)) ~G159 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G159 10)) ~G159)) (~G1483 (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 ((~G1484 (~G166) (CL:LABELS ((~G1485 (!) (CL:TAGBODY ~G164 (CL:COND ((NOT ~G166) (CL:GO ~G165))) (CL:SETQ ! (CL:CAR ~G166)) (STREAM-PRINC ! STR) (CL:SETQ ~G166 (CL:CDR ~G166)) (CL:GO ~G164) ~G165 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1485 NIL)))) (~G1484 X)))) ((CL:LABELS ((~G1486 (~G163) (CL:COND (~G163 ~G163) (T (CHARACTER? X))))) (~G1486 (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 ~G271 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) (CL:GO ~G271)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1487 (~G272) (CL:COND (~G272 ~G272) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1487 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1488 (~G273) (CL:COND (~G273 ~G273) (T (== #\. (CL:CAR X)))))) (~G1488 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1489 (~G274) (CL:COND (~G274 ~G274) (T (== #\. _))))) (~G1489 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN READ-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK READ-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (CL:LABELS ((~G1490 (!) (CL:COND ((== (PEEK-CHAR STR) #\:) (VALUES (CL:LABELS ((~G1491 (~G270) (CL:COND (~G270 ~G270) (T *KEYWORD-PACKAGE*)))) (~G1491 !)) (CL:COND ((READ-CHAR STR) (READ-SYMBOL STR))))) (T (VALUES NIL !))))) (~G1490 (READ-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 ((~G1492 (LOC) (CL:LABELS ((~G1493 (LINE) (CL:LABELS ((~G1494 (COLUMN) (CL:LABELS ((~G1495 (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 ((~G1496 (~G284) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1497 (~G285) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G284)) ~G285)) (~G1497 (CL:PROGN (CL:LABELS ((~G1498 (~G286) (CL:COND ((EQ ~G286 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G286 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G286 '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))))))) (~G1498 TOKEN))))))) (~G1496 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1499 (~G287) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1500 (~G288) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G287)) ~G288)) (~G1500 (CL:PROGN (CL:LABELS ((~G1501 (!) (CL:COND (! (CL:LABELS ((~G1502 (~G290) (CL:LABELS ((~G1503 (~G291) (CL:COND ((NOT (EQ (CL:CAR ~G290) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G290)))) (CL:LABELS ((~G1504 (TOKEN) (CL:LABELS ((~G1505 (~G292) (CL:LABELS ((~G1506 (PKG) (CL:LABELS ((~G1507 (~G293) (CL:LABELS ((~G1508 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1509 (X) (CL:LABELS ((~G1510 (~G297) (CL:LABELS ((~G1511 (~G298) (CL:COND ((NOT (EQ (CL:CAR ~G297) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G297)))) (CL:LABELS ((~G1512 (TOKEN) (CL:LABELS ((~G1513 (~G299) (CL:LABELS ((~G1514 (PKG) (CL:LABELS ((~G1515 (~G300) (CL:LABELS ((~G1516 (SYM) (CL:LABELS ((~G1517 (~G289) (CL:COND (~G289 ~G289) (T (ERR "Only one value allowed after dotted cons."))))) (~G1517 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1516 (CL:CAR ~G300))))) (~G1515 (CL:LABELS ((~G1518 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1518 (CL:CDR ~G299))))))) (~G1514 (CL:CAR ~G299))))) (~G1513 (CL:LABELS ((~G1519 (~G302) (CL:COND (~G302 ~G302) (T (%ERROR "Not enough VALUES."))))) (~G1519 (CL:CDR ~G298))))))) (~G1512 (CL:CAR ~G298))))) (~G1511 (CL:CDR ~G297))))) (~G1510 (READ-TOKEN STR))))) (~G1509 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1508 (CL:CAR ~G293))))) (~G1507 (CL:LABELS ((~G1520 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1520 (CL:CDR ~G292))))))) (~G1506 (CL:CAR ~G292))))) (~G1505 (CL:LABELS ((~G1521 (~G295) (CL:COND (~G295 ~G295) (T (%ERROR "Not enough VALUES."))))) (~G1521 (CL:CDR ~G291))))))) (~G1504 (CL:CAR ~G291))))) (~G1503 (CL:CDR ~G290))))) (~G1502 !))) (T (ERR "Closing bracket missing."))))) (~G1501 (READ-TOKEN STR)))))))) (~G1499 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1522 (~G304) (CL:LABELS ((~G1523 (~G305) (CL:COND ((NOT (EQ (CL:CAR ~G304) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G304)))) (CL:LABELS ((~G1524 (TOKEN) (CL:LABELS ((~G1525 (~G306) (CL:LABELS ((~G1526 (PKG) (CL:LABELS ((~G1527 (~G307) (CL:LABELS ((~G1528 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1528 (CL:CAR ~G307))))) (~G1527 (CL:LABELS ((~G1529 (~G310) (CL:COND (~G310 ~G310) (T (%ERROR "Not enough VALUES."))))) (~G1529 (CL:CDR ~G306))))))) (~G1526 (CL:CAR ~G306))))) (~G1525 (CL:LABELS ((~G1530 (~G309) (CL:COND (~G309 ~G309) (T (%ERROR "Not enough VALUES."))))) (~G1530 (CL:CDR ~G305))))))) (~G1524 (CL:CAR ~G305))))) (~G1523 (CL:CDR ~G304))))) (~G1522 (READ-TOKEN STR)))))) (~G1495 (STREAM-LOCATION-ID LOC))))) (~G1494 (STREAM-LOCATION-COLUMN LOC))))) (~G1493 (STREAM-LOCATION-LINE LOC))))) (~G1492 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1531 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1531 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1532 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G1533 (~G256) (CL:COND (~G256 ~G256) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1533 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1532 (EQ X 'BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1534 (!) (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) ((CONS? PKG) (LIST-STRING PKG)) (T PKG))))))) (~G1534 (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 ((~G1535 (!) (CL:COND (! (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1535 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G1536 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G1536 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G1537 (~G241) (CL:COND (~G241 ~G241) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1537 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1538 (~G242) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G242)) (~G1538 (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 ((~G1539 (~G243) (CL:COND (~G243 ~G243) (T 0)))) (~G1539 (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 ((~G1540 (~G178) (CL:LABELS ((~G1541 (S) (CL:LABELS ((~G1542 (~G179) (CL:COND (~G178 ~G179) (T (GET-STREAM-STRING S))))) (~G1542 (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))))) (~G1541 (DEFAULT-STREAM ~G178))))) (~G1540 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 ((~G1543 (!) (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 !)))))))) (~G1543 (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 (CL:LABELS ((F NIL (CL:LABELS ((~G1544 (!) (CL:COND ((NOT (== ! #\")) (CL:PROGN (CL:CONS (CL:COND ((== ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G1544 (READ-CHAR STR))))) (LIST-STRING (F))))))
  (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 ((CHARACTER? X) (CL:COND ((< X 33) (>= X 0))))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1545 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1545 (READ-CHAR STR))))))
  (CL:DEFUN SEMICOLON? (X) (CL:BLOCK SEMICOLON? (CL:BLOCK NIL (CL:COND (X (== X #\;))))))
  (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 ((~G1546 (!) (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) !)) (~G1546 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 ((~G1547 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1548 (L) (CL:LABELS ((~G1549 (S) (CL:LABELS ((~G1550 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1551 (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)))) (~G1551 0))))) (~G1550 (INTEGER L))))) (~G1549 (FUNCALL MAKER L))))) (~G1548 (- END START)))))))) (~G1547 (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 ((~G1552 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1553 (L) (CL:LABELS ((~G1554 (S) (CL:LABELS ((~G1555 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1556 (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)))) (~G1556 0))))) (~G1555 (INTEGER L))))) (~G1554 (CL:MAKE-STRING 0))))) (~G1553 (- END START)))))))) (~G1552 (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 ((~G1557 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1557 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)))))))
  