anchor.diff:  (CL:DEFVAR *QUASIQUOTE-EXPAND*)
   (CL:DEFVAR *DOT-EXPAND*)
   (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
  -(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1315 (~G1269) (CL:COND (~G1269 ~G1269) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1315 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  +(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G1317 (~G1269) (CL:COND (~G1269 ~G1269) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G1317 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
   (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-ARRAY)))
   (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) (CL:FUNCTION =-AREF)))
   (CL:DEFVAR *ENVIRONMENT-PATH*)
   (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
   (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&OPTIONAL (TARGET NIL)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGET) *ENVIRONMENT-FILENAMES*)) (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
  -(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1316 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1316 (GENSYM))))
  -(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1317 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1317 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  +(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1318 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1318 (GENSYM))))
  +(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1319 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1319 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
   (CL:DEFUN LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (CL:ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
   (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((CL:ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (CL:MAPCAR (CL:FUNCTION MAKE-LAMBDAS) X))))
   (CL:PROGN (CL:DEFUN %ERROR (MSG) (CL:BREAK (NEUTRALIZE-FORMAT-STRING MSG))) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) (CL:FUNCTION %ERROR)))
   (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
   (CL:DEFVAR *EVAL*)
   (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
  -(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1318 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1319 (~G1271) (CL:COND ((INTEGER< ~G1271 0) (ERROR "Negative number of iterations: ~A." ~G1271))) (CL:BLOCK NIL (CL:LABELS ((~G1320 (!) (CL:TAGBODY ~G1272 (CL:COND ((INTEGER== ! ~G1271) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1272)))) (~G1320 0))))) (~G1319 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1318 (CL:LABELS ((~G1321 (~G1270) (CL:COND (~G1270 ~G1270) (T CL:*STANDARD-OUTPUT*)))) (~G1321 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  +(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1320 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1321 (~G1271) (CL:COND ((INTEGER< ~G1271 0) (ERROR "Negative number of iterations: ~A." ~G1271))) (CL:BLOCK NIL (CL:LABELS ((~G1322 (!) (CL:TAGBODY ~G1272 (CL:COND ((INTEGER== ! ~G1271) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1272)))) (~G1322 0))))) (~G1321 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1320 (CL:LABELS ((~G1323 (~G1270) (CL:COND (~G1270 ~G1270) (T CL:*STANDARD-OUTPUT*)))) (~G1323 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
   (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
   (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
   (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
  -(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1322 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1322 (CL:READ-BYTE (CL:LABELS ((~G1323 (~G1273) (CL:COND (~G1273 ~G1273) (T CL:*STANDARD-INPUT*)))) (~G1323 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  +(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1324 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1324 (CL:READ-BYTE (CL:LABELS ((~G1325 (~G1273) (CL:COND (~G1273 ~G1273) (T CL:*STANDARD-INPUT*)))) (~G1325 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
   (CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:ENSURE-DIRECTORIES-EXIST PATHNAME)) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-MKDIR)))
   (CL:PROGN (CL:DEFUN FILE-EXISTS? (PATHNAME) (CL:COND ((CL:PROBE-FILE PATHNAME) T))) (CL:SETF (CL:GETHASH 'FILE-EXISTS? *BUILTIN-ATOMS*) (CL:FUNCTION FILE-EXISTS?)))
   (CL:DEFVAR *FUNCTIONS*)
  
positive.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 (~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 ((~G1407 (~G189) (CL:LABELS ((~G1408 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1409 (A) (CL:LABELS ((~G1410 (~G191) (CL:LABELS ((~G1411 (K) (CL:LABELS ((~G1412 (ARGDEFS) (CL:LABELS ((~G1413 (KEY-ARGS) (CL:LABELS ((~G1414 (NUM) (CL:LABELS ((~G1415 (NO-STATIC) (CL:LABELS ((~G1416 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (CL:RETURN-FROM NIL (ERROR (+ "; Call of function ~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 ((~G1417 (K) (CL:COND (K (CL:LABELS ((~G1418 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1418 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1417 (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 ((~G1419 (~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))))) (~G1419 (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. ~A max, 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 ((~G1420 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1420 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1421 (!) (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)))))) (~G1421 (EXP-MAIN ARGDEFS ALST)))))) (~G1416 NIL)))) (~G1415 NIL)))) (~G1414 0)))) (~G1413 K)))) (~G1412 A)))) (~G1411 (CL:CAR ~G191))))) (~G1410 (CL:LABELS ((~G1422 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1422 (CL:CDR ~G190))))))) (~G1409 (CL:CAR ~G190))))) (~G1408 (CL:CDR ~G189))))) (~G1407 (MAKE-&KEY-ALIST ADEF))))))
  (CL:DEFUN %MACROEXPAND-XLAT (X) (CL:SETQ *CURRENT-MACRO* (CL:CAR X)) (CL:LABELS ((~G1423 (X) (CL:SETQ *CURRENT-MACRO* NIL) X)) (~G1423 (CL:APPLY *MACROCALL* (CL:LIST X)))))
  (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 ((~G1424 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1424 (%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 ((~G1425 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1425 START)))) (CL:LABELS ((~G1426 (~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))))) (~G1426 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1427 (~G112) (CL:LABELS ((~G1428 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1429 (NUM-CDRS) (CL:LABELS ((~G1430 (~G114) (CL:LABELS ((~G1431 (WITHOUT-START) (CL:LABELS ((~G1432 (~G117) (CL:LABELS ((~G1433 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1434 (NUM-CARS) (CL:LABELS ((~G1435 (~G119) (CL:LABELS ((~G1436 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1436 (CL:CAR ~G119))))) (~G1435 (CL:LABELS ((~G1437 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1437 (CL:CDR ~G118))))))) (~G1434 (CL:CAR ~G118))))) (~G1433 (CL:CDR ~G117))))) (~G1432 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1431 (CL:CAR ~G114))))) (~G1430 (CL:LABELS ((~G1438 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1438 (CL:CDR ~G113))))))) (~G1429 (CL:CAR ~G113))))) (~G1428 (CL:CDR ~G112))))) (~G1427 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1439 (SL) (CL:LABELS ((~G1440 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1440 (== #\. (CL:CAR SL)))))) (~G1439 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1441 (SL) (CL:LABELS ((~G1442 (L) (CL:LABELS ((~G1443 (P) (CL:LABELS ((~G1444 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1444 (== 1 L))))) (~G1443 (DOT-POSITION SL))))) (~G1442 (CL:LENGTH SL))))) (~G1441 (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 ((~G1445 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1445 (READ-CHAR STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1446 (~G277) (CL:COND ((EQ ~G277 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G277 'CHAR) (READ-CHAR STR)) ((EQ ~G277 'NUMBER) (CL:LABELS ((~G1447 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1447 (MAKE-STRING-STREAM)))) ((EQ ~G277 'HEXNUM) (READ-HEX STR)) ((EQ ~G277 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G277 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1448 (~G276) (CL:COND ((EQUAL ~G276 'BRACKET-CLOSE) "Round") ((EQUAL ~G276 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G276 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1448 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1446 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 ((~G1449 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1450 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1451 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1452 (~G248) (CL:COND (~G248 ~G248) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1452 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1451 (EQ X 'QUASIQUOTE))))))) (~G1450 (EQ X 'BACKQUOTE))))))) (~G1449 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1453 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1454 (~G311) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G305)) ~G311)) (~G1454 (CL:PROGN (CL:LABELS ((~G1455 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1456 (~G306) (CL:LABELS ((~G1457 (~G307) (CL:COND ((NOT (EQ (CL:CAR ~G306) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G306)))) (CL:LABELS ((~G1458 (TOKEN) (CL:LABELS ((~G1459 (~G308) (CL:LABELS ((~G1460 (PKG) (CL:LABELS ((~G1461 (~G309) (CL:LABELS ((~G1462 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1462 (CL:CAR ~G309))))) (~G1461 (CL:LABELS ((~G1463 (~G313) (CL:COND (~G313 ~G313) (T (%ERROR "Not enough VALUES."))))) (~G1463 (CL:CDR ~G308))))))) (~G1460 (CL:CAR ~G308))))) (~G1459 (CL:LABELS ((~G1464 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1464 (CL:CDR ~G307))))))) (~G1458 (CL:CAR ~G307))))) (~G1457 (CL:CDR ~G306))))) (~G1456 (READ-TOKEN STR))))) (T !)))) (~G1455 (READ-CONS STR)))))))) (~G1453 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1465 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1466 (~G271) (CL:LABELS ((~G1467 (~G272) (CL:COND ((NOT (EQ (CL:CAR ~G271) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G271)))) (CL:LABELS ((~G1468 (PKG) (CL:LABELS ((~G1469 (~G273) (CL:LABELS ((~G1470 (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 ((~G1471 (~G270) (CL:COND ((CHARACTER== ~G270 #\() 'BRACKET-OPEN) ((CHARACTER== ~G270 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G270 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G270 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G270 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G270 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G270 #\') 'CL:QUOTE) ((CHARACTER== ~G270 #\`) 'BACKQUOTE) ((CHARACTER== ~G270 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G270 #\") 'DBLQUOTE) ((CHARACTER== ~G270 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G270 #\#) (CL:LABELS ((~G1472 (~G269) (CL:COND ((CHARACTER== ~G269 #\\) 'CHAR) ((CHARACTER== ~G269 #\x) 'HEXNUM) ((CHARACTER== ~G269 #\') 'CL:FUNCTION) ((CHARACTER== ~G269 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1472 (READ-CHAR STR)))) ((CHARACTER== ~G270 -1) 'EOF)))) (~G1471 (READ-CHAR STR))))))) PKG SYM))) (~G1470 (CL:CAR ~G273))))) (~G1469 (CL:LABELS ((~G1473 (~G275) (CL:COND (~G275 ~G275) (T (%ERROR "Not enough VALUES."))))) (~G1473 (CL:CDR ~G272))))))) (~G1468 (CL:CAR ~G272))))) (~G1467 (CL:CDR ~G271))))) (~G1466 !))))))) (~G1465 (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 ((~G1474 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1474 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1475 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1475 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1476 (~G177) (CL:LABELS ((~G1477 (S) (CL:LABELS ((~G1478 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1478 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1477 (DEFAULT-STREAM ~G177))))) (~G1476 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1479 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1479 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1480 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1480 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 ((~G1481 (~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)) (~G1481 (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 ((~G1482 (~G164) (CL:LABELS ((~G1483 (!) (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))))) (~G1483 NIL)))) (~G1482 X)))) ((CL:LABELS ((~G1484 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1484 (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 ((~G1485 (~G267) (CL:COND (~G267 ~G267) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1485 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1486 (~G266) (CL:COND (~G266 ~G266) (T (== #\. (CL:CAR X)))))) (~G1486 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1487 (~G268) (CL:COND (~G268 ~G268) (T (== #\. _))))) (~G1487 (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 ((~G1488 (SYM) (CL:LABELS ((~G1489 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1490 (~G264) (CL:COND (~G264 ~G264) (T T)))) (~G1490 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1489 (PEEK-CHAR STR))))) (~G1488 (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 ((~G1491 (LOC) (CL:LABELS ((~G1492 (LINE) (CL:LABELS ((~G1493 (COLUMN) (CL:LABELS ((~G1494 (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 ((~G1495 (~G279) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1496 (~G282) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G279)) ~G282)) (~G1496 (CL:PROGN (CL:LABELS ((~G1497 (~G278) (CL:COND ((EQ ~G278 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G278 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G278 '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))))))) (~G1497 TOKEN))))))) (~G1495 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1498 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1499 (~G288) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G281)) ~G288)) (~G1499 (CL:PROGN (CL:LABELS ((~G1500 (!) (CL:COND (! (CL:LABELS ((~G1501 (~G283) (CL:LABELS ((~G1502 (~G284) (CL:COND ((NOT (EQ (CL:CAR ~G283) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G283)))) (CL:LABELS ((~G1503 (TOKEN) (CL:LABELS ((~G1504 (~G285) (CL:LABELS ((~G1505 (PKG) (CL:LABELS ((~G1506 (~G286) (CL:LABELS ((~G1507 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1508 (X) (CL:LABELS ((~G1509 (~G291) (CL:LABELS ((~G1510 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1511 (TOKEN) (CL:LABELS ((~G1512 (~G293) (CL:LABELS ((~G1513 (PKG) (CL:LABELS ((~G1514 (~G294) (CL:LABELS ((~G1515 (SYM) (CL:LABELS ((~G1516 (~G280) (CL:COND (~G280 ~G280) (T (ERR "Only one value allowed after dotted cons."))))) (~G1516 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1515 (CL:CAR ~G294))))) (~G1514 (CL:LABELS ((~G1517 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1517 (CL:CDR ~G293))))))) (~G1513 (CL:CAR ~G293))))) (~G1512 (CL:LABELS ((~G1518 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1518 (CL:CDR ~G292))))))) (~G1511 (CL:CAR ~G292))))) (~G1510 (CL:CDR ~G291))))) (~G1509 (READ-TOKEN STR))))) (~G1508 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1507 (CL:CAR ~G286))))) (~G1506 (CL:LABELS ((~G1519 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1519 (CL:CDR ~G285))))))) (~G1505 (CL:CAR ~G285))))) (~G1504 (CL:LABELS ((~G1520 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1520 (CL:CDR ~G284))))))) (~G1503 (CL:CAR ~G284))))) (~G1502 (CL:CDR ~G283))))) (~G1501 !))) (T (ERR "Closing bracket missing."))))) (~G1500 (READ-TOKEN STR)))))))) (~G1498 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1521 (~G298) (CL:LABELS ((~G1522 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1523 (TOKEN) (CL:LABELS ((~G1524 (~G300) (CL:LABELS ((~G1525 (PKG) (CL:LABELS ((~G1526 (~G301) (CL:LABELS ((~G1527 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1527 (CL:CAR ~G301))))) (~G1526 (CL:LABELS ((~G1528 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1528 (CL:CDR ~G300))))))) (~G1525 (CL:CAR ~G300))))) (~G1524 (CL:LABELS ((~G1529 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1529 (CL:CDR ~G299))))))) (~G1523 (CL:CAR ~G299))))) (~G1522 (CL:CDR ~G298))))) (~G1521 (READ-TOKEN STR)))))) (~G1494 (STREAM-LOCATION-ID LOC))))) (~G1493 (STREAM-LOCATION-COLUMN LOC))))) (~G1492 (STREAM-LOCATION-LINE LOC))))) (~G1491 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1530 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1530 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1531 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G1532 (~G250) (CL:COND (~G250 ~G250) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1532 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1531 (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 ((~G1533 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (CL:COND (*READER-FINDS-SYMBOLS?* (CL:FIND-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) CL:*PACKAGE*) (T (CL:FIND-PACKAGE (CL:COND ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))))) (~G1533 (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 ((~G1534 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1534 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1535 (~G235) (CL:COND (~G235 ~G235) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1535 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1536 (~G236) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G236)) (~G1536 (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 ((~G1537 (~G237) (CL:COND (~G237 ~G237) (T 0)))) (~G1537 (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 ((~G1538 (~G175) (CL:LABELS ((~G1539 (S) (CL:LABELS ((~G1540 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1540 (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))))) (~G1539 (DEFAULT-STREAM ~G175))))) (~G1538 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 ((~G1541 (!) (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 !)))))))) (~G1541 (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 ((~G1542 (~G13) (CL:LABELS ((~G1543 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1544 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1545 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1545 (> N I))))))) (~G1544 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1543 NIL)))) (~G1542 X))))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1546 (STREAM-LOCATION) (CL:LABELS ((~G1547 (TRACK?) (CL:LABELS ((~G1548 (ID) (CL:LABELS ((~G1549 (LINE) (CL:LABELS ((~G1550 (COLUMN) (CL:LABELS ((~G1551 (TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1552 (~G160) (CL:LABELS ((~G1553 (!) (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))))) (~G1553 NIL)))) (~G1552 (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)) (~G1551 (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))) (~G1550 (STREAM-LOCATION-COLUMN STREAM-LOCATION))))) (~G1549 (STREAM-LOCATION-LINE STREAM-LOCATION))))) (~G1548 (STREAM-LOCATION-ID STREAM-LOCATION))))) (~G1547 (STREAM-LOCATION-TRACK? STREAM-LOCATION))))) (~G1546 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 ((~G1554 (!) (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) !)) (~G1554 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 ((~G1555 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1556 (L) (CL:LABELS ((~G1557 (S) (CL:LABELS ((~G1558 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1559 (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)))) (~G1559 0))))) (~G1558 (INTEGER L))))) (~G1557 (FUNCALL MAKER L))))) (~G1556 (- END START)))))))) (~G1555 (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 ((~G1560 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1561 (L) (CL:LABELS ((~G1562 (S) (CL:LABELS ((~G1563 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1564 (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)))) (~G1564 0))))) (~G1563 (INTEGER L))))) (~G1562 (CL:MAKE-STRING 0))))) (~G1561 (- END START)))))))) (~G1560 (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 ((~G1565 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1565 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)))))))
  
negative.code: (CL:PROGN (CL:DEFUN NUMBER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'NUMBER> *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER>)))
  (CL:PROGN (CL:DEFUN INTEGER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'INTEGER> *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER>)))
  (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1357 (TESTS) (CL:LABELS ((~G1358 (END) (CL:COND ((NOT BODY) (CL:PROGN (ERROR "Body is missing.")))) (CL:CONS 'CL:COND (APPEND (CL:COND ((SOLE? END) (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END)))) (T TESTS)) NIL)))) (~G1358 (CL:CAR (CL:LAST TESTS)))))) (~G1357 (GROUP BODY 2))))))
  (CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  (CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (%MACROEXPAND-CALL (CL:COND ((EQ (CL:CAR X) 'CL:QUOTE) X) (T (%MACROEXPAND-REST X)))))))
  (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  (CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1359 (~G131) (CL:LABELS ((~G1360 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1360 NIL)))) (~G1359 LST))))))))
  (CL:DEFUN TRE-SYMBOL (X) (CL:BLOCK TRE-SYMBOL (CL:BLOCK NIL (CL:INTERN (SYMBOL-NAME X) "TRE"))))
  (CL:DEFUN CLOSE (STR) (CL:BLOCK CLOSE (CL:BLOCK NIL (%FCLOSE (STREAM-HANDLE STR)))))
  (CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1361 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1361 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  (CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  (CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1362 (~G125) (CL:LABELS ((~G1363 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1363 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1362 X)) (CL:LABELS ((~G1364 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1364 *DEFAULT-LISTPROP*)))) (T X)))))
  (CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (SKIP-SPACES STR) (CL:COND ((PEEK-CHAR STR) (READ-EXPR STR))))))
  (CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1365 (~G234) (CL:COND (~G234 ~G234) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1365 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1366 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1367 (~G335) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G334)) ~G335)) (~G1367 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1366 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1368 (~G735) (CL:COND ((CL:ATOM ~G735) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G735) (QQ _)) ((QUASIQUOTE-SPLICE? ~G735) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1368 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1369 (~G736) (CL:COND ((QUOTE? ~G736) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G736) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1369 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING (CL:FUNCTION DISP)))))))
  (CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((== _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  (CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1370 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1370 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  (CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  (CL:DEFUN GENSYM NIL (CL:LABELS ((~G1371 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1371 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  (CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1372 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1372 (CL:CAR X))))
  (CL:DEFUN IDENTITY (X) X)
  (CL:DEFVAR *GENSYM-PREFIX*)
  (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
  (CL:DEFVAR *STANDARD-INPUT*)
  (CL:DEFVAR *DEFINITION-PRINTER*)
  (CL:DEFVAR *MACROEXPAND-BACKQUOTE*)
  (CL:DEFVAR *MACROCALL*)
  (CL:DEFVAR *MACRO?*)
  (CL:DEFVAR +CL-FUNCTION-IMPORTS+)
  (CL:DEFUN %MACROEXPAND-BACKQUOTE (X) (CL:COND ((CL:ATOM X) X) ((CL:ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND-BACKQUOTE (CL:CAR X)) (%MACROEXPAND-BACKQUOTE (CL:CDR X))))))
  (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 ((~G1373 (L) (CL:LABELS ((~G1374 (S) (CL:BLOCK NIL (CL:LABELS ((~G1375 (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)))) (~G1375 (-- L)))) S)) (~G1374 NIL)))) (~G1373 (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 ((~G1376 (Y) (CL:LABELS ((~G1377 (A) (CL:PROGN (CL:LABELS ((~G1378 (~G734) (CL:LABELS ((~G1379 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1379 (CL:COND ((CONS? ~G734) (CPR ~G734))))))) (~G1378 I)) (CL:LABELS ((~G1380 (~G733) (RPLACP (CL:CONS A (TREE-WALK (CL:CDR I) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF)) ~G733))) (~G1380 *DEFAULT-LISTPROP*))))) (~G1377 (CL:LABELS ((~G1381 (~G732) (CL:COND (~G732 ~G732) (T (CL:COND ((CL:COND (DONT-ASCEND-AFTER-IF (FUNCALL DONT-ASCEND-AFTER-IF Y))) (FUNCALL ASCENDING Y)) (T (TREE-WALK (CL:COND (ASCENDING (FUNCALL ASCENDING Y)) (T Y)) :ASCENDING ASCENDING :DONT-ASCEND-IF DONT-ASCEND-IF :DONT-ASCEND-AFTER-IF DONT-ASCEND-AFTER-IF))))))) (~G1381 (CL:COND (DONT-ASCEND-IF (CL:COND ((FUNCALL DONT-ASCEND-IF Y) Y)))))))))) (~G1376 (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 ((~G1382 (~G432) (CL:COND (~G432 ~G432) (T (CL:LABELS ((~G1383 (~G433) (CL:COND (~G433 ~G433) (T (CL:LABELS ((~G1384 (~G434) (CL:COND (~G434 ~G434) (T (CL:LABELS ((~G1385 (~G435) (CL:COND (~G435 ~G435) (T (CL:LABELS ((~G1386 (~G436) (CL:COND (~G436 ~G436) (T (HASH-TABLE? X))))) (~G1386 (ARRAY? X))))))) (~G1385 (STRING? X))))))) (~G1384 (NUMBER? X))))))) (~G1383 (EQ T X))))))) (~G1382 (NOT X))))))
  (CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1387 (~G179) (CL:LABELS ((~G1388 (S) (CL:LABELS ((~G1389 (~G180) (CL:COND (~G179 ~G180) (T (GET-STREAM-STRING S))))) (~G1389 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1388 (DEFAULT-STREAM ~G179))))) (~G1387 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 ((~G1390 (~G233) (CL:COND (~G233 ~G233) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1390 (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 ((~G1391 (~G315) (CL:LABELS ((~G1392 (~G316) (CL:COND ((NOT (EQ (CL:CAR ~G315) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G315)))) (CL:LABELS ((~G1393 (TOKEN) (CL:LABELS ((~G1394 (~G317) (CL:LABELS ((~G1395 (PKG) (CL:LABELS ((~G1396 (~G318) (CL:LABELS ((~G1397 (SYM) (CL:LABELS ((~G1398 (~G314) (CL:COND ((EQ ~G314 NIL) NIL) ((EQ ~G314 'EOF) NIL) ((EQ ~G314 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G314 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G314 'CURLY-BRACKET-OPEN) (CL:CONS 'CURLY (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1398 TOKEN)))) (~G1397 (CL:CAR ~G318))))) (~G1396 (CL:LABELS ((~G1399 (~G321) (CL:COND (~G321 ~G321) (T (%ERROR "Not enough VALUES."))))) (~G1399 (CL:CDR ~G317))))))) (~G1395 (CL:CAR ~G317))))) (~G1394 (CL:LABELS ((~G1400 (~G320) (CL:COND (~G320 ~G320) (T (%ERROR "Not enough VALUES."))))) (~G1400 (CL:CDR ~G316))))))) (~G1393 (CL:CAR ~G316))))) (~G1392 (CL:CDR ~G315))))) (~G1391 (READ-TOKEN STR))))))
  (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:LABELS ((~G1401 (C) (CL:COND (C (CL:PROGN (CL:COND ((== #\; C) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((WHITESPACE? C) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR))))))))) (~G1401 (PEEK-CHAR STR))))))
  (CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:LABELS ((~G1402 (SL) (CL:LABELS ((~G1403 (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))))))) (~G1403 (DOT-POSITION SL))))) (~G1402 (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 (NATIVE-MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (NATIVE-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 ((~G1404 (~G156) (CL:PROGN (=-AREF 'STRUCT ~G156 0) (=-AREF 'STREAM-LOCATION ~G156 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G156 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G156 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G156 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G156 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G156 6)) ~G156)) (~G1404 (MAKE-ARRAY 7))))))
  (CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1405 (~G166) (CL:COND ((EQUAL ~G166 'INPUT) "r") ((EQUAL ~G166 'OUTPUT) "w") ((EQUAL ~G166 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1405 DIRECTION)))))
  (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN CDRLIST (~G127) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G127))))
  (CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1406 (~G182) (CL:COND (~G182 ~G182) (T (%KEY? X))))) (~G1406 (%REST-OR-%BODY? X))))))
  (CL:DEFUN %MACROEXPAND-CALL (X) (CL:COND ((CL:APPLY *MACRO?* (CL:LIST X)) (%MACROEXPAND-XLAT X)) (T X)))
  (CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((CL:ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  (CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (CONCATENATE-SUBLISTS? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1407 (!) (CL:COND ((CL:LABELS ((~G1408 (~G194) (CL:COND (~G194 ~G194) (T (EQ ! 'ERROR))))) (~G1408 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1407 (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)))))))
  