anchor.diff:  (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 ((~G944 (~G173) (CL:COND (~G173 ~G173) (T (CL:LABELS ((~G945 (~G174) (CL:COND (~G174 ~G174) (T (CL:LABELS ((~G946 (~G175) (CL:COND (~G175 ~G175) (T (EQL X 'CL:&KEY))))) (~G946 (EQL X 'CL:&OPTIONAL))))))) (~G945 (EQL X 'CL:&BODY))))))) (~G944 (EQL X 'CL:&REST))))))
  +(CL:DEFUN ARGUMENT-KEYWORD? (X) (CL:BLOCK ARGUMENT-KEYWORD? (CL:BLOCK NIL (CL:LABELS ((~G944 (~G166) (CL:COND (~G166 ~G166) (T (CL:LABELS ((~G945 (~G167) (CL:COND (~G167 ~G167) (T (CL:LABELS ((~G946 (~G168) (CL:COND (~G168 ~G168) (T (EQL X 'CL:&KEY))))) (~G946 (EQL X 'CL:&OPTIONAL))))))) (~G945 (EQL X 'CL:&BODY))))))) (~G944 (EQL 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 ((~G947 (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 ((~G948 (!) (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 _)))) (~G948 (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))))) (~G947 NIL)))))
   (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 (~G110) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G110))))
  -(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 ((~G949 (~G179) (CL:LABELS ((~G950 (~G180) (CL:LABELS ((~G951 (A) (CL:LABELS ((~G952 (~G181) (CL:LABELS ((~G953 (K) (CL:LABELS ((~G954 (ARGDEFS) (CL:LABELS ((~G955 (KEY-ARGS) (CL:LABELS ((~G956 (NUM) (CL:LABELS ((~G957 (NO-STATIC) (CL:LABELS ((~G958 (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 ((~G959 (K) (CL:COND (K (CL:LABELS ((~G960 (!) (CL:LABELS ((~G961 (~G178) (CL:COND (~G178 ~G178) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (CL:LIST (CL:CAR !)))))))) (~G961 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G960 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G959 (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 ((~G962 (~G176) (CL:COND ((EQ ~G176 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G176 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G176 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G962 (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 ((~G963 (~G177) (CL:COND (~G177 ~G177) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G963 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G964 (!) (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)))))) (~G964 (EXP-MAIN ARGDEFS ALST)))))) (~G958 NIL)))) (~G957 NIL)))) (~G956 0)))) (~G955 K)))) (~G954 A)))) (~G953 (CL:CAR ~G181))))) (~G952 (CL:CDR ~G180))))) (~G951 (CL:CAR ~G180))))) (~G950 (CL:CDR ~G179))))) (~G949 (MAKE-&KEY-ALIST ADEF))))))
  +(CL:DEFUN CARLIST (~G103) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G103))))
  +(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 ((~G949 (~G172) (CL:LABELS ((~G950 (~G173) (CL:LABELS ((~G951 (A) (CL:LABELS ((~G952 (~G174) (CL:LABELS ((~G953 (K) (CL:LABELS ((~G954 (ARGDEFS) (CL:LABELS ((~G955 (KEY-ARGS) (CL:LABELS ((~G956 (NUM) (CL:LABELS ((~G957 (NO-STATIC) (CL:LABELS ((~G958 (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 ((~G959 (K) (CL:COND (K (CL:LABELS ((~G960 (!) (CL:LABELS ((~G961 (~G171) (CL:COND (~G171 ~G171) (T (CL:RETURN-FROM NIL (ERR "Value of argument ~A missing." (CL:LIST (CL:CAR !)))))))) (~G961 (CL:CDR !))) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G960 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G959 (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 ((~G962 (~G169) (CL:COND ((EQ ~G169 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G169 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G169 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G962 (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 ((~G963 (~G170) (CL:COND (~G170 ~G170) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G963 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G964 (!) (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)))))) (~G964 (EXP-MAIN ARGDEFS ALST)))))) (~G958 NIL)))) (~G957 NIL)))) (~G956 0)))) (~G955 K)))) (~G954 A)))) (~G953 (CL:CAR ~G174))))) (~G952 (CL:CDR ~G173))))) (~G951 (CL:CAR ~G173))))) (~G950 (CL:CDR ~G172))))) (~G949 (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 ((~G965 (~G170) (CL:COND (~G170 ~G170) (T (%BODY? X))))) (~G965 (%REST? X))))))
  +(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G965 (~G163) (CL:COND (~G163 ~G163) (T (%BODY? X))))) (~G965 (%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 ((~G966 (~G50) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G50)))) (~G966 START)))) (CL:LABELS ((~G967 (~G51) (CL:COND ((CONS? ~G51) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G51) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G51) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G967 SEQ))))))))
  -(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G968 (~G100) (CL:LABELS ((~G969 (~G101) (CL:LABELS ((~G970 (NUM-CDRS) (CL:LABELS ((~G971 (~G102) (CL:LABELS ((~G972 (WITHOUT-START) (CL:LABELS ((~G973 (~G104) (CL:LABELS ((~G974 (~G105) (CL:LABELS ((~G975 (NUM-CARS) (CL:LABELS ((~G976 (~G106) (CL:LABELS ((~G977 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G977 (CL:CAR ~G106))))) (~G976 (CL:CDR ~G105))))) (~G975 (CL:CAR ~G105))))) (~G974 (CL:CDR ~G104))))) (~G973 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G972 (CL:CAR ~G102))))) (~G971 (CL:CDR ~G101))))) (~G970 (CL:CAR ~G101))))) (~G969 (CL:CDR ~G100))))) (~G968 (DOT-EXPAND-HEAD-LENGTH X))))))
  -(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G978 (SL) (CL:LABELS ((~G979 (~G109) (CL:COND (~G109 ~G109) (T (EQL #\. (CL:CAR (CL:LAST SL))))))) (~G979 (EQL #\. (CL:CAR SL)))))) (~G978 (STRING-LIST (SYMBOL-NAME X)))))))
  -(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G980 (SL) (CL:LABELS ((~G981 (L) (CL:LABELS ((~G982 (P) (CL:LABELS ((~G983 (~G108) (CL:COND (~G108 ~G108) (T (NOT P))))) (~G983 (== 1 L))))) (~G982 (DOT-POSITION SL))))) (~G981 (CL:LENGTH SL))))) (~G980 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G966 (~G43) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G43)))) (~G966 START)))) (CL:LABELS ((~G967 (~G44) (CL:COND ((CONS? ~G44) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G44) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G44) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G967 SEQ))))))))
  +(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G968 (~G93) (CL:LABELS ((~G969 (~G94) (CL:LABELS ((~G970 (NUM-CDRS) (CL:LABELS ((~G971 (~G95) (CL:LABELS ((~G972 (WITHOUT-START) (CL:LABELS ((~G973 (~G97) (CL:LABELS ((~G974 (~G98) (CL:LABELS ((~G975 (NUM-CARS) (CL:LABELS ((~G976 (~G99) (CL:LABELS ((~G977 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G977 (CL:CAR ~G99))))) (~G976 (CL:CDR ~G98))))) (~G975 (CL:CAR ~G98))))) (~G974 (CL:CDR ~G97))))) (~G973 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G972 (CL:CAR ~G95))))) (~G971 (CL:CDR ~G94))))) (~G970 (CL:CAR ~G94))))) (~G969 (CL:CDR ~G93))))) (~G968 (DOT-EXPAND-HEAD-LENGTH X))))))
  +(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G978 (SL) (CL:LABELS ((~G979 (~G102) (CL:COND (~G102 ~G102) (T (EQL #\. (CL:CAR (CL:LAST SL))))))) (~G979 (EQL #\. (CL:CAR SL)))))) (~G978 (STRING-LIST (SYMBOL-NAME X)))))))
  +(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G980 (SL) (CL:LABELS ((~G981 (L) (CL:LABELS ((~G982 (P) (CL:LABELS ((~G983 (~G101) (CL:COND (~G101 ~G101) (T (NOT P))))) (~G983 (== 1 L))))) (~G982 (DOT-POSITION SL))))) (~G981 (CL:LENGTH SL))))) (~G980 (STRING-LIST (SYMBOL-NAME X)))))))
   (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION CHARACTER==)))))
   (CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((EQL #\; (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 ((~G984 (~G267) (CL:COND ((EQ ~G267 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G267 :CHAR) (READ-CHAR STR)) ((EQ ~G267 :NUMBER) (CL:LABELS ((~G985 (S) (PRINC SYM S) (READ-NUMBER S))) (~G985 (MAKE-STRING-STREAM)))) ((EQ ~G267 :HEXNUM) (READ-HEX STR)) ((EQ ~G267 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G267 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G986 (~G268) (CL:COND ((EQL ~G268 :BRACKET-CLOSE) "round") ((EQL ~G268 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G268 :SQUARE-BRACKET-CLOSE) "square")))) (~G986 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G984 TOKEN)))))
  +(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G984 (~G260) (CL:COND ((EQ ~G260 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G260 :CHAR) (READ-CHAR STR)) ((EQ ~G260 :NUMBER) (CL:LABELS ((~G985 (S) (PRINC SYM S) (READ-NUMBER S))) (~G985 (MAKE-STRING-STREAM)))) ((EQ ~G260 :HEXNUM) (READ-HEX STR)) ((EQ ~G260 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G260 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "Unexpected closing ~A bracket." (CL:LABELS ((~G986 (~G261) (CL:COND ((EQL ~G261 :BRACKET-CLOSE) "round") ((EQL ~G261 :CURLY-BRACKET-CLOSE) "curly") ((EQL ~G261 :SQUARE-BRACKET-CLOSE) "square")))) (~G986 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G984 TOKEN)))))
   (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST (MAKE-SYMBOL (SYMBOL-NAME TOKEN)) (READ-EXPR STR)))))
  -(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G987 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G988 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G989 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G990 (~G240) (CL:COND (~G240 ~G240) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G990 (EQL X :QUASIQUOTE-SPLICE))))))) (~G989 (EQL X :QUASIQUOTE))))))) (~G988 (EQL X :BACKQUOTE))))))) (~G987 (EQL X :QUOTE))))))
  -(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G991 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G992 (~G286) (CL:LABELS ((~G993 (~G287) (CL:LABELS ((~G994 (TOKEN) (CL:LABELS ((~G995 (~G288) (CL:LABELS ((~G996 (PKG) (CL:LABELS ((~G997 (~G289) (CL:LABELS ((~G998 (SYM) (READ-SLOT-VALUE (CL:LIST ! SYM)))) (~G998 (CL:CAR ~G289))))) (~G997 (CL:CDR ~G288))))) (~G996 (CL:CAR ~G288))))) (~G995 (CL:CDR ~G287))))) (~G994 (CL:CAR ~G287))))) (~G993 (CL:CDR ~G286))))) (~G992 (READ-TOKEN STR))))) (T !)))) (~G991 (READ-CONS STR))))))
  -(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G999 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1000 (~G263) (CL:LABELS ((~G1001 (~G264) (CL:LABELS ((~G1002 (PKG) (CL:LABELS ((~G1003 (~G265) (CL:LABELS ((~G1004 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (EQL #\. (CL:CAR SYM)))))) :DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) :NUMBER) (T :SYMBOL))) (T (CL:LABELS ((~G1005 (~G261) (CL:COND ((EQL ~G261 #\() :BRACKET-OPEN) ((EQL ~G261 #\)) :BRACKET-CLOSE) ((EQL ~G261 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G261 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G261 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G261 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G261 #\') :QUOTE) ((EQL ~G261 #\`) :BACKQUOTE) ((EQL ~G261 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G261 #\") :DBLQUOTE) ((EQL ~G261 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G261 #\#) (CL:LABELS ((~G1006 (~G262) (CL:COND ((EQL ~G262 #\\) :CHAR) ((EQL ~G262 #\x) :HEXNUM) ((EQL ~G262 #\') :FUNCTION) ((EQL ~G262 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1006 (READ-CHAR STR)))) ((EQL ~G261 -1) :EOF)))) (~G1005 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1004 (CL:CAR ~G265))))) (~G1003 (CL:CDR ~G264))))) (~G1002 (CL:CAR ~G264))))) (~G1001 (CL:CDR ~G263))))) (~G1000 !))))))) (~G999 (READ-SYMBOL-AND-PACKAGE STR))))))
  +(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G987 (~G230) (CL:COND (~G230 ~G230) (T (CL:LABELS ((~G988 (~G231) (CL:COND (~G231 ~G231) (T (CL:LABELS ((~G989 (~G232) (CL:COND (~G232 ~G232) (T (CL:LABELS ((~G990 (~G233) (CL:COND (~G233 ~G233) (T (EQL X :ACCENT-CIRCONFLEX))))) (~G990 (EQL X :QUASIQUOTE-SPLICE))))))) (~G989 (EQL X :QUASIQUOTE))))))) (~G988 (EQL X :BACKQUOTE))))))) (~G987 (EQL X :QUOTE))))))
  +(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G991 (!) (CL:COND ((EQL #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G992 (~G279) (CL:LABELS ((~G993 (~G280) (CL:LABELS ((~G994 (TOKEN) (CL:LABELS ((~G995 (~G281) (CL:LABELS ((~G996 (PKG) (CL:LABELS ((~G997 (~G282) (CL:LABELS ((~G998 (SYM) (READ-SLOT-VALUE (CL:LIST ! SYM)))) (~G998 (CL:CAR ~G282))))) (~G997 (CL:CDR ~G281))))) (~G996 (CL:CAR ~G281))))) (~G995 (CL:CDR ~G280))))) (~G994 (CL:CAR ~G280))))) (~G993 (CL:CDR ~G279))))) (~G992 (READ-TOKEN STR))))) (T !)))) (~G991 (READ-CONS STR))))))
  +(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G999 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1000 (~G256) (CL:LABELS ((~G1001 (~G257) (CL:LABELS ((~G1002 (PKG) (CL:LABELS ((~G1003 (~G258) (CL:LABELS ((~G1004 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (EQL #\. (CL:CAR SYM)))))) :DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) :NUMBER) (T :SYMBOL))) (T (CL:LABELS ((~G1005 (~G254) (CL:COND ((EQL ~G254 #\() :BRACKET-OPEN) ((EQL ~G254 #\)) :BRACKET-CLOSE) ((EQL ~G254 #\[) :SQUARE-BRACKET-OPEN) ((EQL ~G254 #\]) :SQUARE-BRACKET-CLOSE) ((EQL ~G254 #\{) :CURLY-BRACKET-OPEN) ((EQL ~G254 #\}) :CURLY-BRACKET-CLOSE) ((EQL ~G254 #\') :QUOTE) ((EQL ~G254 #\`) :BACKQUOTE) ((EQL ~G254 #\^) :ACCENT-CIRCONFLEX) ((EQL ~G254 #\") :DBLQUOTE) ((EQL ~G254 #\,) (CL:COND ((EQL #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) :QUASIQUOTE-SPLICE))) (T :QUASIQUOTE))) ((EQL ~G254 #\#) (CL:LABELS ((~G1006 (~G255) (CL:COND ((EQL ~G255 #\\) :CHAR) ((EQL ~G255 #\x) :HEXNUM) ((EQL ~G255 #\') :FUNCTION) ((EQL ~G255 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1006 (READ-CHAR STR)))) ((EQL ~G254 -1) :EOF)))) (~G1005 (READ-CHAR STR))))))) PKG (LIST-STRING SYM)))) (~G1004 (CL:CAR ~G258))))) (~G1003 (CL:CDR ~G257))))) (~G1002 (CL:CAR ~G257))))) (~G1001 (CL:CDR ~G256))))) (~G1000 !))))))) (~G999 (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 ((~G1007 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1007 (STREAM-PEEKED-CHAR STR))))))
  -(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1008 (~G155) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G155)) (~G1008 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  -(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1009 (~G166) (CL:LABELS ((~G1010 (S) (CL:LABELS ((~G1011 (~G167) (CL:COND (~G166 ~G167) (T (GET-STREAM-STRING S))))) (~G1011 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1010 (DEFAULT-STREAM ~G166))))) (~G1009 STR)))))
  +(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1008 (~G148) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G148)) (~G1008 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  +(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1009 (~G159) (CL:LABELS ((~G1010 (S) (CL:LABELS ((~G1011 (~G160) (CL:COND (~G159 ~G160) (T (GET-STREAM-STRING S))))) (~G1011 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1010 (DEFAULT-STREAM ~G159))))) (~G1009 STR)))))
   (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1012 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1012 (STREAM-OUTPUT-LOCATION STR))))))
  -(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1013 (~G149) (CL:COND ((EQ ~G149 NIL) (MAKE-STRING-STREAM)) ((EQ ~G149 T) *STANDARD-OUTPUT*) (T X)))) (~G1013 X)))))
  +(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1013 (~G142) (CL:COND ((EQ ~G142 NIL) (MAKE-STRING-STREAM)) ((EQ ~G142 T) *STANDARD-OUTPUT*) (T X)))) (~G1013 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 ((~G1014 (~G140) (CL:PROGN (=-AREF 'STRUCT ~G140 0) (=-AREF 'STREAM ~G140 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G140 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G140 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G140 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G140 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G140 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G140 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G140 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G140 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G140 10)) ~G140)) (~G1014 (MAKE-ARRAY 11))))))
  +(CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1014 (~G133) (CL:PROGN (=-AREF 'STRUCT ~G133 0) (=-AREF 'STREAM ~G133 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G133 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G133 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G133 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G133 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G133 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G133 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G133 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G133 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G133 10)) ~G133)) (~G1014 (MAKE-ARRAY 11))))))
   (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 ((~G1015 (L) (CL:LABELS ((~G1016 (S) (CL:BLOCK NIL (CL:LABELS ((~G1017 (I) (CL:TAGBODY ~G80 (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 ~G80)))) (~G1017 (-- L)))) S)) (~G1016 NIL)))) (~G1015 (CL:LENGTH X))))))
  +(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1015 (L) (CL:LABELS ((~G1016 (S) (CL:BLOCK NIL (CL:LABELS ((~G1017 (I) (CL:TAGBODY ~G73 (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 ~G73)))) (~G1017 (-- L)))) S)) (~G1016 NIL)))) (~G1015 (CL:LENGTH X))))))
   (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 ((~G1018 (~G406) (CL:COND (~G406 ~G406) (T (CL:LABELS ((~G1019 (~G407) (CL:COND (~G407 ~G407) (T (CL:LABELS ((~G1020 (~G408) (CL:COND (~G408 ~G408) (T (CL:LABELS ((~G1021 (~G409) (CL:COND (~G409 ~G409) (T (CL:LABELS ((~G1022 (~G410) (CL:COND (~G410 ~G410) (T (CL:LABELS ((~G1023 (~G411) (CL:COND (~G411 ~G411) (T (HASH-TABLE? X))))) (~G1023 (ARRAY? X))))))) (~G1022 (STRING? X))))))) (~G1021 (CHARACTER? X))))))) (~G1020 (NUMBER? X))))))) (~G1019 (EQ T X))))))) (~G1018 (NOT X))))))
  -(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1024 (~G168) (CL:LABELS ((~G1025 (S) (CL:LABELS ((~G1026 (~G169) (CL:COND (~G168 ~G169) (T (GET-STREAM-STRING S))))) (~G1026 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1025 (DEFAULT-STREAM ~G168))))) (~G1024 STR)))))
  +(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1018 (~G402) (CL:COND (~G402 ~G402) (T (CL:LABELS ((~G1019 (~G403) (CL:COND (~G403 ~G403) (T (CL:LABELS ((~G1020 (~G404) (CL:COND (~G404 ~G404) (T (CL:LABELS ((~G1021 (~G405) (CL:COND (~G405 ~G405) (T (CL:LABELS ((~G1022 (~G406) (CL:COND (~G406 ~G406) (T (CL:LABELS ((~G1023 (~G407) (CL:COND (~G407 ~G407) (T (HASH-TABLE? X))))) (~G1023 (ARRAY? X))))))) (~G1022 (STRING? X))))))) (~G1021 (CHARACTER? X))))))) (~G1020 (NUMBER? X))))))) (~G1019 (EQ T X))))))) (~G1018 (NOT X))))))
  +(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1024 (~G161) (CL:LABELS ((~G1025 (S) (CL:LABELS ((~G1026 (~G162) (CL:COND (~G161 ~G162) (T (GET-STREAM-STRING S))))) (~G1026 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1025 (DEFAULT-STREAM ~G161))))) (~G1024 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 ((~G1027 (~G225) (CL:COND (~G225 ~G225) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1027 (READ-PEEKED-CHAR STR))))))
  +(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1027 (~G218) (CL:COND (~G218 ~G218) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1027 (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 ((~G1028 (~G292) (CL:LABELS ((~G1029 (~G293) (CL:LABELS ((~G1030 (TOKEN) (CL:LABELS ((~G1031 (~G294) (CL:LABELS ((~G1032 (PKG) (CL:LABELS ((~G1033 (~G295) (CL:LABELS ((~G1034 (SYM) (CL:LABELS ((~G1035 (~G291) (CL:COND ((EQL ~G291 NIL) NIL) ((EQL ~G291 :EOF) NIL) ((EQL ~G291 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G291 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G291 :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))))))) (~G1035 TOKEN)))) (~G1034 (CL:CAR ~G295))))) (~G1033 (CL:CDR ~G294))))) (~G1032 (CL:CAR ~G294))))) (~G1031 (CL:CDR ~G293))))) (~G1030 (CL:CAR ~G293))))) (~G1029 (CL:CDR ~G292))))) (~G1028 (READ-TOKEN STR))))))
  +(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1028 (~G285) (CL:LABELS ((~G1029 (~G286) (CL:LABELS ((~G1030 (TOKEN) (CL:LABELS ((~G1031 (~G287) (CL:LABELS ((~G1032 (PKG) (CL:LABELS ((~G1033 (~G288) (CL:LABELS ((~G1034 (SYM) (CL:LABELS ((~G1035 (~G284) (CL:COND ((EQL ~G284 NIL) NIL) ((EQL ~G284 :EOF) NIL) ((EQL ~G284 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G284 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G284 :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))))))) (~G1035 TOKEN)))) (~G1034 (CL:CAR ~G288))))) (~G1033 (CL:CDR ~G287))))) (~G1032 (CL:CAR ~G287))))) (~G1031 (CL:CDR ~G286))))) (~G1030 (CL:CAR ~G286))))) (~G1029 (CL:CDR ~G285))))) (~G1028 (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 ((~G1036 (SL) (CL:LABELS ((~G1037 (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))))))) (~G1037 (DOT-POSITION SL))))) (~G1036 (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 ((~G1038 (~G139) (CL:PROGN (=-AREF 'STRUCT ~G139 0) (=-AREF 'STREAM-LOCATION ~G139 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G139 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G139 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G139 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G139 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G139 6)) ~G139)) (~G1038 (MAKE-ARRAY 7))))))
  -(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1039 (~G150) (CL:COND ((EQL ~G150 'INPUT) "r") ((EQL ~G150 'OUTPUT) "w") ((EQL ~G150 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1039 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 ((~G1038 (~G132) (CL:PROGN (=-AREF 'STRUCT ~G132 0) (=-AREF 'STREAM-LOCATION ~G132 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G132 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G132 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G132 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G132 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G132 6)) ~G132)) (~G1038 (MAKE-ARRAY 7))))))
  +(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1039 (~G143) (CL:COND ((EQL ~G143 'INPUT) "r") ((EQL ~G143 'OUTPUT) "w") ((EQL ~G143 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1039 DIRECTION)))))
   (CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
  -(CL:DEFUN CDRLIST (~G111) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G111))))
  -(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1040 (~G171) (CL:COND (~G171 ~G171) (T (%KEY? X))))) (~G1040 (%REST-OR-%BODY? X))))))
  +(CL:DEFUN CDRLIST (~G104) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G104))))
  +(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1040 (~G164) (CL:COND (~G164 ~G164) (T (%KEY? X))))) (~G1040 (%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 ((~G1041 (!) (CL:COND ((CL:LABELS ((~G1042 (~G183) (CL:COND (~G183 ~G183) (T (EQ ! 'ERROR))))) (~G1042 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1041 (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 ((~G1041 (!) (CL:COND ((CL:LABELS ((~G1042 (~G176) (CL:COND (~G176 ~G176) (T (EQ ! 'ERROR))))) (~G1042 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1041 (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 GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:CONS (COPY-HEAD X SIZE) (GROUP (CL:NTHCDR SIZE X) SIZE)))))))
   (CL:DEFVAR *STANDARD-OUTPUT*)
  
positive.code: (CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G864 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G864 (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 ((> (CL:CHAR-CODE X) 32) (NOT (SPECIAL-CHAR? X)))))))))
  (CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G865 (~G70) (CL:COND (~G70 ~G70) (T (CL:LABELS ((~G866 (~G71) (CL:COND (~G71 ~G71) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G866 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G865 (DIGIT-CHAR? X))))))
  (CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CODE-CHAR (- (+ (CL:CHAR-CODE C) (CL:CHAR-CODE #\A)) (CL:CHAR-CODE #\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 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:BLOCK 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 ((~G867 (~G97) (CL:LABELS ((~G868 (SEQ) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ SEQ (CL:CAR ~G97)) (CL:LABELS ((~G869 (~G98) (CL:BLOCK NIL (CL:LABELS ((~G870 (!) (CL:TAGBODY ~G99 (CL:COND ((== ! ~G98) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G871 (~G94) (CL:COND (~G94 ~G94) (T (CL:RETURN-FROM EVERY NIL))))) (~G871 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G99)))) (~G870 0))))) (~G869 (CL:LENGTH SEQ))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G868 NIL)))) (~G867 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G872 (~G69) (CL:COND (~G69 ~G69) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G872 (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 ((~G873 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G874 (~G141) (CL:COND (~G141 (CL:PROGN (CL:LABELS ((~G875 (~G143) (CL:BLOCK NIL (CL:LABELS ((~G876 (~G142) (CL:TAGBODY ~G144 (CL:COND ((== ~G142 ~G143) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G877 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G877 (ELT ~G141 ~G142))) (CL:SETQ ~G142 (NUMBER+ 1 ~G142)) (CL:GO ~G144)))) (~G876 0))))) (~G875 (CL:LENGTH ~G141)))))))) (~G874 X))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 (CL:CHAR-CODE 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 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G873 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: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 ((~G878 (~G148) (CL:LABELS ((~G879 (!) (CL:TAGBODY ~G146 (CL:COND ((NOT ~G148) (CL:GO ~G147))) (CL:SETQ ! (CL:CAR ~G148)) (STREAM-PRINC ! STR) (CL:SETQ ~G148 (CL:CDR ~G148)) (CL:GO ~G146) ~G147 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G879 NIL)))) (~G878 X)))) ((CL:LABELS ((~G880 (~G145) (CL:COND (~G145 ~G145) (T (CHARACTER? X))))) (~G880 (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 (FUNCALL (STREAM-FUN-OUT STR) X STR))))))
  (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 (LIST-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 ~G257 (CL:COND ((NOT (NOT (CL:COND ((EQL #\| (READ-CHAR STR)) (EQL #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) (CL:GO ~G257)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G881 (~G258) (CL:COND (~G258 ~G258) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G881 (CL:COND ((CL:CDR X) (CL:LABELS ((~G882 (~G259) (CL:COND (~G259 ~G259) (T (EQL #\. (CL:CAR X)))))) (~G882 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G883 (~G260) (CL:COND (~G260 ~G260) (T (EQL #\. _))))) (~G883 (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 ((~G884 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G885 (~G256) (CL:COND (~G256 ~G256) (T *KEYWORD-PACKAGE*)))) (~G885 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G884 (READ-SYMBOL STR))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND ((NOT X) NIL) ((CL:CDR X) (CL:CONS 'CL:SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X)) "TRE") NIL)) NIL)))) ((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 ((ERR (_) (CL:BLOCK NIL (CL:LABELS ((~G886 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G886 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-BRACKET? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G887 (~G269) (CL:COND ((EQL ~G269 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G269 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQL ~G269 :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))))))) (~G887 TOKEN)) (CL:LABELS ((~G888 (!) (CL:COND (! (CL:LABELS ((~G889 (~G271) (CL:LABELS ((~G890 (~G272) (CL:LABELS ((~G891 (TOKEN) (CL:LABELS ((~G892 (~G273) (CL:LABELS ((~G893 (PKG) (CL:LABELS ((~G894 (~G274) (CL:LABELS ((~G895 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G896 (X) (CL:LABELS ((~G897 (~G276) (CL:LABELS ((~G898 (~G277) (CL:LABELS ((~G899 (TOKEN) (CL:LABELS ((~G900 (~G278) (CL:LABELS ((~G901 (PKG) (CL:LABELS ((~G902 (~G279) (CL:LABELS ((~G903 (SYM) (CL:LABELS ((~G904 (~G270) (CL:COND (~G270 ~G270) (T (ERR "Only one value allowed after dotted cons"))))) (~G904 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G903 (CL:CAR ~G279))))) (~G902 (CL:CDR ~G278))))) (~G901 (CL:CAR ~G278))))) (~G900 (CL:CDR ~G277))))) (~G899 (CL:CAR ~G277))))) (~G898 (CL:CDR ~G276))))) (~G897 (READ-TOKEN STR))))) (~G896 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G895 (CL:CAR ~G274))))) (~G894 (CL:CDR ~G273))))) (~G893 (CL:CAR ~G273))))) (~G892 (CL:CDR ~G272))))) (~G891 (CL:CAR ~G272))))) (~G890 (CL:CDR ~G271))))) (~G889 !))) (T (ERR "Closing bracket missing"))))) (~G888 (READ-TOKEN STR))))))))) (CL:LABELS ((~G905 (~G281) (CL:LABELS ((~G906 (~G282) (CL:LABELS ((~G907 (TOKEN) (CL:LABELS ((~G908 (~G283) (CL:LABELS ((~G909 (PKG) (CL:LABELS ((~G910 (~G284) (CL:LABELS ((~G911 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G911 (CL:CAR ~G284))))) (~G910 (CL:CDR ~G283))))) (~G909 (CL:CAR ~G283))))) (~G908 (CL:CDR ~G282))))) (~G907 (CL:CAR ~G282))))) (~G906 (CL:CDR ~G281))))) (~G905 (READ-TOKEN STR)))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G912 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G913 (~G242) (CL:COND (~G242 ~G242) (T (EQL X :CURLY-BRACKET-CLOSE))))) (~G913 (EQL X :SQUARE-BRACKET-CLOSE))))))) (~G912 (EQL X :BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G914 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL SYM PKG))))) (~G914 (SPLIT #\. SYM))))))
  (CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((REC (V) (CL:LABELS ((~G915 (!) (CL:COND (! (CL:PROGN (READ-CHAR STR) (REC (NUMBER+ (* V 16) (- (CL:CHAR-CODE !) (CL:COND ((DIGIT-CHAR? !) (CL:CHAR-CODE #\0)) (T (- (CL:CHAR-CODE #\A) 10)))))))) (T V)))) (~G915 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G916 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G916 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G917 (~G227) (CL:COND (~G227 ~G227) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G917 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G918 (~G228) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G228)) (~G918 (REC 0)))))))
  (CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((EQL #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G919 (~G229) (CL:COND (~G229 ~G229) (T 0)))) (~G919 (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 ((~G920 (~G164) (CL:LABELS ((~G921 (S) (CL:LABELS ((~G922 (~G165) (CL:COND (~G164 ~G165) (T (GET-STREAM-STRING S))))) (~G922 (CL:PROGN (CL:COND ((NUMBER-NOT-CHARACTER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S)) (T (STREAM-PRINC X S))) X))))) (~G921 (DEFAULT-STREAM ~G164))))) (~G920 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) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (CL:COND ((STRING? X) (CL:LABELS ((~G923 (~G151) (CL:COND (~G151 (CL:PROGN (CL:LABELS ((~G924 (~G153) (CL:BLOCK NIL (CL:LABELS ((~G925 (~G152) (CL:TAGBODY ~G154 (CL:COND ((== ~G152 ~G153) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G926 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G926 (ELT ~G151 ~G152))) (CL:SETQ ~G152 (NUMBER+ 1 ~G152)) (CL:GO ~G154)))) (~G925 0))))) (~G924 (CL:LENGTH ~G151)))))))) (~G923 X))) (T (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:BLOCK NIL (CL:LABELS ((~G927 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G927 (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 ((< (CL:CHAR-CODE X) 33) (>= (CL:CHAR-CODE X) 0))))))))
  
negative.code: (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 ((~G822 (~G61) (CL:COND (~G61 ~G61) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G822 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  (CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? 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 ((~G823 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G823 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G45) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G824 (~G49) (CL:LABELS ((~G825 (C) (CL:TAGBODY ~G47 (CL:COND ((NOT ~G49) (CL:GO ~G48))) (CL:SETQ C (CL:CAR ~G49)) (CL:LABELS ((~G826 (~G46) (CL:COND (~G46 ~G46) (T (CL:RETURN-FROM NIL NIL))))) (~G826 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G49 (CL:CDR ~G49)) (CL:GO ~G47) ~G48 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G825 NIL)))) (~G824 ~G45))))))
  (CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (CL:MAPCAR (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G827 (~G236) (CL:COND (~G236 ~G236) (T (CL:LABELS ((~G828 (~G237) (CL:COND (~G237 ~G237) (T (CL:LABELS ((~G829 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G830 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G831 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G832 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G833 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G834 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G835 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G836 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G837 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G838 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G839 (~G248) (CL:COND (~G248 ~G248) (T (EQL X #\^))))) (~G839 (EQL X #\#))))))) (~G838 (EQL X #\;))))))) (~G837 (EQL X #\:))))))) (~G836 (EQL X #\,))))))) (~G835 (EQL X #\`))))))) (~G834 (EQL X #\'))))))) (~G833 (EQL X #\"))))))) (~G832 (EQL X #\}))))))) (~G831 (EQL X #\{))))))) (~G830 (EQL X #\]))))))) (~G829 (EQL X #\[))))))) (~G828 (EQL X #\)))))))) (~G827 (EQL 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 ((~G840 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G840 (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 DECIMALS-CHARS (X) (CL:BLOCK DECIMALS-CHARS (CL:BLOCK NIL (CL:LABELS ((~G841 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G841 (CL:MOD (* X 10) 10))))))
  (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 ((~G842 (E) (CL:LABELS ((~G843 (S) (CL:COND ((CL:LABELS ((~G844 (~G84) (CL:COND (~G84 ~G84) (T (CL:COND ((< S E) FROM-END)))))) (~G844 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G845 (~G85) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G85)))) (~G845 S)))) (CL:BLOCK NIL (CL:LABELS ((~G846 (I) (CL:TAGBODY ~G86 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G847 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G847 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G86)))) (~G846 S))))) (~G843 (CL:LABELS ((~G848 (~G83) (CL:COND (~G83 ~G83) (T 0)))) (~G848 START)))))) (~G842 (CL:LABELS ((~G849 (~G82) (CL:COND (~G82 ~G82) (T (-- (CL:LENGTH SEQ)))))) (~G849 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G850 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G851 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G852 (~G81) (CL:LABELS ((~G853 (I) (CL:TAGBODY ~G79 (CL:COND ((NOT ~G81) (CL:GO ~G80))) (CL:SETQ I (CL:CAR ~G81)) (CL:COND ((FUNCALL PRED I IDX) (CL:RETURN-FROM NIL I))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G81 (CL:CDR ~G81)) (CL:GO ~G79) ~G80 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G853 NIL)))) (~G852 !))))) (~G851 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G854 (~G78) (CL:LABELS ((~G855 (I) (CL:TAGBODY ~G76 (CL:COND ((NOT ~G78) (CL:GO ~G77))) (CL:SETQ I (CL:CAR ~G78)) (CL:COND ((FUNCALL PRED I) (CL:RETURN-FROM NIL I))) (CL:SETQ ~G78 (CL:CDR ~G78)) (CL:GO ~G76) ~G77 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G855 NIL)))) (~G854 !))))))) (~G850 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G856 (!) (CL:BLOCK NIL (CL:LABELS ((~G857 (~G20) (CL:LABELS ((~G858 (I) (CL:TAGBODY ~G18 (CL:COND ((NOT ~G20) (CL:GO ~G19))) (CL:SETQ I (CL:CAR ~G20)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G20 (CL:CDR ~G20)) (CL:GO ~G18) ~G19 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G858 NIL)))) (~G857 LST))))) (~G856 NIL)))))
  (CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G859 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G859 (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))))))
  