anchor.diff:  (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 ((~G814 (~G68) (CL:COND (~G68 ~G68) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G814 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
  +(CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G820 (~G68) (CL:COND (~G68 ~G68) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G820 (%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 ((~G815 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G815 (POSITION OBJ SEQ :TEST TEST))))))))
  -(CL:DEFUN LOWER-CASE? (CL:&REST ~G52) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G816 (~G56) (CL:LABELS ((~G817 (C) (CL:TAGBODY ~G54 (CL:COND ((NOT ~G56) (CL:GO ~G55))) (CL:SETQ C (CL:CAR ~G56)) (CL:LABELS ((~G818 (~G53) (CL:COND (~G53 ~G53) (T (CL:RETURN-FROM NIL NIL))))) (~G818 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G56 (CL:CDR ~G56)) (CL:GO ~G54) ~G55 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G817 NIL)))) (~G816 ~G52))))))
  +(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 ((~G821 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (CL:LIST SEQ))))) (~G821 (POSITION OBJ SEQ :TEST TEST))))))))
  +(CL:DEFUN LOWER-CASE? (CL:&REST ~G52) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G822 (~G56) (CL:LABELS ((~G823 (C) (CL:TAGBODY ~G54 (CL:COND ((NOT ~G56) (CL:GO ~G55))) (CL:SETQ C (CL:CAR ~G56)) (CL:LABELS ((~G824 (~G53) (CL:COND (~G53 ~G53) (T (CL:RETURN-FROM NIL NIL))))) (~G824 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G56 (CL:CDR ~G56)) (CL:GO ~G54) ~G55 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G823 NIL)))) (~G822 ~G52))))))
   (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:COND (X (CL:LABELS ((~G819 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G820 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G821 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G822 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G823 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G824 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G825 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G826 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G827 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G828 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G829 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G830 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G831 (~G255) (CL:COND (~G255 ~G255) (T (CHARACTER== X #\^))))) (~G831 (CHARACTER== X #\#))))))) (~G830 (CHARACTER== X #\;))))))) (~G829 (CHARACTER== X #\:))))))) (~G828 (CHARACTER== X #\,))))))) (~G827 (CHARACTER== X #\`))))))) (~G826 (CHARACTER== X #\'))))))) (~G825 (CHARACTER== X #\"))))))) (~G824 (CHARACTER== X #\}))))))) (~G823 (CHARACTER== X #\{))))))) (~G822 (CHARACTER== X #\]))))))) (~G821 (CHARACTER== X #\[))))))) (~G820 (CHARACTER== X #\)))))))) (~G819 (CHARACTER== X #\())))))))
  +(CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:LABELS ((~G825 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G826 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G827 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G828 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G829 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G830 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G831 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G832 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G833 (~G251) (CL:COND (~G251 ~G251) (T (CL:LABELS ((~G834 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G835 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G836 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G837 (~G255) (CL:COND (~G255 ~G255) (T (CHARACTER== X #\^))))) (~G837 (CHARACTER== X #\#))))))) (~G836 (CHARACTER== X #\;))))))) (~G835 (CHARACTER== X #\:))))))) (~G834 (CHARACTER== X #\,))))))) (~G833 (CHARACTER== X #\`))))))) (~G832 (CHARACTER== X #\'))))))) (~G831 (CHARACTER== X #\"))))))) (~G830 (CHARACTER== X #\}))))))) (~G829 (CHARACTER== X #\{))))))) (~G828 (CHARACTER== X #\]))))))) (~G827 (CHARACTER== X #\[))))))) (~G826 (CHARACTER== X #\)))))))) (~G825 (CHARACTER== 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 ((~G832 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G832 (PEEK-CHAR STR))))))
  +(CL:DEFUN PEEK-DIGIT (STR) (CL:BLOCK PEEK-DIGIT (CL:BLOCK NIL (CL:LABELS ((~G838 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G838 (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 ((~G833 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G833 (CL:MOD (* X 10) 10))))))
  +(CL:DEFUN DECIMALS-CHARS (X) (CL:BLOCK DECIMALS-CHARS (CL:BLOCK NIL (CL:LABELS ((~G839 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G839 (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 ((~G834 (E) (CL:LABELS ((~G835 (S) (CL:COND ((CL:LABELS ((~G836 (~G91) (CL:COND (~G91 ~G91) (T (CL:COND ((< S E) FROM-END)))))) (~G836 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G837 (~G92) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G92)))) (~G837 S)))) (CL:BLOCK NIL (CL:LABELS ((~G838 (I) (CL:TAGBODY ~G93 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G839 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G839 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G93)))) (~G838 S))))) (~G835 (CL:LABELS ((~G840 (~G90) (CL:COND (~G90 ~G90) (T 0)))) (~G840 START)))))) (~G834 (CL:LABELS ((~G841 (~G89) (CL:COND (~G89 ~G89) (T (-- (CL:LENGTH SEQ)))))) (~G841 END)))))))))))
  -(CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G842 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G843 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G844 (~G88) (CL:LABELS ((~G845 (!) (CL:TAGBODY ~G86 (CL:COND ((NOT ~G88) (CL:GO ~G87))) (CL:SETQ ! (CL:CAR ~G88)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G88 (CL:CDR ~G88)) (CL:GO ~G86) ~G87 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G845 NIL)))) (~G844 !))))) (~G843 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G846 (~G85) (CL:LABELS ((~G847 (!) (CL:TAGBODY ~G83 (CL:COND ((NOT ~G85) (CL:GO ~G84))) (CL:SETQ ! (CL:CAR ~G85)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G85 (CL:CDR ~G85)) (CL:GO ~G83) ~G84 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G847 NIL)))) (~G846 !))))))) (~G842 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  -(CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G848 (!) (CL:BLOCK NIL (CL:LABELS ((~G849 (~G27) (CL:LABELS ((~G850 (I) (CL:TAGBODY ~G25 (CL:COND ((NOT ~G27) (CL:GO ~G26))) (CL:SETQ I (CL:CAR ~G27)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G27 (CL:CDR ~G27)) (CL:GO ~G25) ~G26 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G850 NIL)))) (~G849 LST))))) (~G848 NIL)))))
  -(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G851 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G851 (CL:CAR LSTS)))))))))
  +(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 ((~G840 (E) (CL:LABELS ((~G841 (S) (CL:COND ((CL:LABELS ((~G842 (~G91) (CL:COND (~G91 ~G91) (T (CL:COND ((< S E) FROM-END)))))) (~G842 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G843 (~G92) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G92)))) (~G843 S)))) (CL:BLOCK NIL (CL:LABELS ((~G844 (I) (CL:TAGBODY ~G93 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G845 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (CL:LIST I))))) (CL:RETURN-FROM NIL !))))) (~G845 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G93)))) (~G844 S))))) (~G841 (CL:LABELS ((~G846 (~G90) (CL:COND (~G90 ~G90) (T 0)))) (~G846 START)))))) (~G840 (CL:LABELS ((~G847 (~G89) (CL:COND (~G89 ~G89) (T (-- (CL:LENGTH SEQ)))))) (~G847 END)))))))))))
  +(CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G848 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G849 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G850 (~G88) (CL:LABELS ((~G851 (!) (CL:TAGBODY ~G86 (CL:COND ((NOT ~G88) (CL:GO ~G87))) (CL:SETQ ! (CL:CAR ~G88)) (CL:COND ((FUNCALL PRED ! IDX) (CL:RETURN-FROM NIL !))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G88 (CL:CDR ~G88)) (CL:GO ~G86) ~G87 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G851 NIL)))) (~G850 !))))) (~G849 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G852 (~G85) (CL:LABELS ((~G853 (!) (CL:TAGBODY ~G83 (CL:COND ((NOT ~G85) (CL:GO ~G84))) (CL:SETQ ! (CL:CAR ~G85)) (CL:COND ((FUNCALL PRED !) (CL:RETURN-FROM NIL !))) (CL:SETQ ~G85 (CL:CDR ~G85)) (CL:GO ~G83) ~G84 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G853 NIL)))) (~G852 !))))))) (~G848 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  +(CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G854 (!) (CL:BLOCK NIL (CL:LABELS ((~G855 (~G27) (CL:LABELS ((~G856 (I) (CL:TAGBODY ~G25 (CL:COND ((NOT ~G27) (CL:GO ~G26))) (CL:SETQ I (CL:CAR ~G27)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G27 (CL:CDR ~G27)) (CL:GO ~G25) ~G26 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G856 NIL)))) (~G855 LST))))) (~G854 NIL)))))
  +(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:PROGN (CL:LABELS ((~G857 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (CL:LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G857 (CL:CAR LSTS)))))))))
   (CL:DEFUN =-ELT (VAL SEQ IDX) (CL:BLOCK =-ELT (CL:BLOCK NIL (%SET-ELT VAL SEQ IDX))))
   (CL:DEFUN FIND-IF (PRED SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (WITH-INDEX NIL)) (CL:BLOCK FIND-IF (CL:BLOCK NIL (CL:COND ((NOT (CL:ATOM SEQ) START END) (%FIND-IF-LIST PRED SEQ FROM-END WITH-INDEX)) (T (%FIND-IF-SEQUENCE PRED SEQ START END FROM-END WITH-INDEX))))))
  -(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G852 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G852 (CL:CAR X))) VALS))) VALS)))
  -(CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G853 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G853 (CL:CAR (CL:CDR X)))))))
  -(CL:DEFUN PRINC-NUMBER (X STR) (CL:BLOCK PRINC-NUMBER (CL:BLOCK NIL (CL:COND ((< X 0) (PRINC #\- STR))) (STREAM-PRINC (INTEGER-CHARS X) STR) (CL:LABELS ((~G854 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (DECIMALS-CHARS !) STR)))))) (~G854 (CL:MOD X 1))))))
  +(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G858 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G858 (CL:CAR X))) VALS))) VALS)))
  +(CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G859 (~G8) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (CL:RPLACA X NIL))) (CL:COND ((CL:CDR X) (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G859 (CL:CAR (CL:CDR X)))))))
  +(CL:DEFUN PRINC-NUMBER (X STR) (CL:BLOCK PRINC-NUMBER (CL:BLOCK NIL (CL:COND ((< X 0) (PRINC #\- STR))) (STREAM-PRINC (INTEGER-CHARS X) STR) (CL:LABELS ((~G860 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (DECIMALS-CHARS !) STR)))))) (~G860 (CL:MOD X 1))))))
   (CL:DEFUN NUMBER-NOT-CHARACTER? (X) (CL:BLOCK NUMBER-NOT-CHARACTER? (CL:BLOCK NIL (CL:COND ((NOT (CHARACTER? X)) (NUMBER? X))))))
  -(CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G855 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G855 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  -(CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G856 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G856 (PEEK-CHAR STR))))))
  +(CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G861 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G861 (PEEK-CHAR STR))) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
  +(CL:DEFUN PEEK-DOT (STR) (CL:BLOCK PEEK-DOT (CL:BLOCK NIL (CL:LABELS ((~G862 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G862 (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 ((~G857 (~G70) (CL:COND (~G70 ~G70) (T (CL:LABELS ((~G858 (~G71) (CL:COND (~G71 ~G71) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G858 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G857 (DIGIT-CHAR? X))))))
  +(CL:DEFUN HEX-DIGIT-CHAR? (X) (CL:BLOCK HEX-DIGIT-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G863 (~G70) (CL:COND (~G70 ~G70) (T (CL:LABELS ((~G864 (~G71) (CL:COND (~G71 ~G71) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G864 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G863 (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: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 ((~G859 (~G97) (CL:LABELS ((~G860 (SEQ) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ SEQ (CL:CAR ~G97)) (CL:LABELS ((~G861 (~G98) (CL:BLOCK NIL (CL:LABELS ((~G862 (!) (CL:TAGBODY ~G99 (CL:COND ((== ! ~G98) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G863 (~G94) (CL:COND (~G94 ~G94) (T (CL:RETURN-FROM EVERY NIL))))) (~G863 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G99)))) (~G862 0))))) (~G861 (CL:LENGTH SEQ))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G860 NIL)))) (~G859 SEQS))))))
  -(CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G864 (~G69) (CL:COND (~G69 ~G69) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G864 (DECIMAL-DIGIT? C))))))))
  +(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G865 (~G97) (CL:LABELS ((~G866 (SEQ) (CL:TAGBODY ~G95 (CL:COND ((NOT ~G97) (CL:GO ~G96))) (CL:SETQ SEQ (CL:CAR ~G97)) (CL:LABELS ((~G867 (~G98) (CL:BLOCK NIL (CL:LABELS ((~G868 (!) (CL:TAGBODY ~G99 (CL:COND ((== ! ~G98) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G869 (~G94) (CL:COND (~G94 ~G94) (T (CL:RETURN-FROM EVERY NIL))))) (~G869 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G99)))) (~G868 0))))) (~G867 (CL:LENGTH SEQ))) (CL:SETQ ~G97 (CL:CDR ~G97)) (CL:GO ~G95) ~G96 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G866 NIL)))) (~G865 SEQS))))))
  +(CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G870 (~G69) (CL:COND (~G69 ~G69) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G870 (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 ((~G865 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G866 (~G141) (CL:COND (~G141 (CL:PROGN (CL:LABELS ((~G867 (~G143) (CL:BLOCK NIL (CL:LABELS ((~G868 (~G142) (CL:TAGBODY ~G144 (CL:COND ((== ~G142 ~G143) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G869 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G869 (ELT ~G141 ~G142))) (CL:SETQ ~G142 (NUMBER+ 1 ~G142)) (CL:GO ~G144)))) (~G868 0))))) (~G867 (CL:LENGTH ~G141)))))))) (~G866 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)) (~G865 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 %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G871 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G872 (~G141) (CL:COND (~G141 (CL:PROGN (CL:LABELS ((~G873 (~G143) (CL:BLOCK NIL (CL:LABELS ((~G874 (~G142) (CL:TAGBODY ~G144 (CL:COND ((== ~G142 ~G143) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G875 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G875 (ELT ~G141 ~G142))) (CL:SETQ ~G142 (NUMBER+ 1 ~G142)) (CL:GO ~G144)))) (~G874 0))))) (~G873 (CL:LENGTH ~G141)))))))) (~G872 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)) (~G871 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 ((~G870 (~G148) (CL:LABELS ((~G871 (!) (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))))) (~G871 NIL)))) (~G870 X)))) ((CL:LABELS ((~G872 (~G145) (CL:COND (~G145 ~G145) (T (CHARACTER? X))))) (~G872 (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-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G876 (~G148) (CL:LABELS ((~G877 (!) (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))))) (~G877 NIL)))) (~G876 X)))) ((CL:LABELS ((~G878 (~G145) (CL:COND (~G145 ~G145) (T (CHARACTER? X))))) (~G878 (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 ((~G873 (~G258) (CL:COND (~G258 ~G258) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G873 (CL:COND ((CL:CDR X) (CL:LABELS ((~G874 (~G259) (CL:COND (~G259 ~G259) (T (EQL #\. (CL:CAR X)))))) (~G874 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G875 (~G260) (CL:COND (~G260 ~G260) (T (EQL #\. _))))) (~G875 (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 ((~G876 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (VALUES (CL:LABELS ((~G877 (~G256) (CL:COND (~G256 ~G256) (T *KEYWORD-PACKAGE*)))) (~G877 !)) (CL:COND ((READ-CHAR STR) (READ-SYMBOL STR))))) (T (VALUES "TRE" !))))) (~G876 (READ-SYMBOL STR))))))
  +(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G879 (~G258) (CL:COND (~G258 ~G258) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G879 (CL:COND ((CL:CDR X) (CL:LABELS ((~G880 (~G259) (CL:COND (~G259 ~G259) (T (EQL #\. (CL:CAR X)))))) (~G880 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G881 (~G260) (CL:COND (~G260 ~G260) (T (EQL #\. _))))) (~G881 (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 ((~G882 (!) (CL:COND ((EQL (PEEK-CHAR STR) #\:) (VALUES (CL:LABELS ((~G883 (~G256) (CL:COND (~G256 ~G256) (T *KEYWORD-PACKAGE*)))) (~G883 !)) (CL:COND ((READ-CHAR STR) (READ-SYMBOL STR))))) (T (VALUES "TRE" !))))) (~G882 (READ-SYMBOL STR))))))
   (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS '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)))) (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 ((~G878 (LOC) (CL:LABELS ((~G879 (LINE) (CL:LABELS ((~G880 (COLUMN) (CL:LABELS ((~G881 (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 ((~G882 (~G269) (CL:COND ((EQUAL ~G269 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQUAL ~G269 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQUAL ~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))))))) (~G882 TOKEN)) (CL:LABELS ((~G883 (!) (CL:COND (! (CL:LABELS ((~G884 (~G271) (CL:LABELS ((~G885 (~G272) (CL:LABELS ((~G886 (TOKEN) (CL:LABELS ((~G887 (~G273) (CL:LABELS ((~G888 (PKG) (CL:LABELS ((~G889 (~G274) (CL:LABELS ((~G890 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G891 (X) (CL:LABELS ((~G892 (~G276) (CL:LABELS ((~G893 (~G277) (CL:LABELS ((~G894 (TOKEN) (CL:LABELS ((~G895 (~G278) (CL:LABELS ((~G896 (PKG) (CL:LABELS ((~G897 (~G279) (CL:LABELS ((~G898 (SYM) (CL:LABELS ((~G899 (~G270) (CL:COND (~G270 ~G270) (T (ERR "Only one value allowed after dotted cons."))))) (~G899 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G898 (CL:CAR ~G279))))) (~G897 (CL:CDR ~G278))))) (~G896 (CL:CAR ~G278))))) (~G895 (CL:CDR ~G277))))) (~G894 (CL:CAR ~G277))))) (~G893 (CL:CDR ~G276))))) (~G892 (READ-TOKEN STR))))) (~G891 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G890 (CL:CAR ~G274))))) (~G889 (CL:CDR ~G273))))) (~G888 (CL:CAR ~G273))))) (~G887 (CL:CDR ~G272))))) (~G886 (CL:CAR ~G272))))) (~G885 (CL:CDR ~G271))))) (~G884 !))) (T (ERR "Closing bracket missing."))))) (~G883 (READ-TOKEN STR))))))))) (CL:LABELS ((~G900 (~G281) (CL:LABELS ((~G901 (~G282) (CL:LABELS ((~G902 (TOKEN) (CL:LABELS ((~G903 (~G283) (CL:LABELS ((~G904 (PKG) (CL:LABELS ((~G905 (~G284) (CL:LABELS ((~G906 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G906 (CL:CAR ~G284))))) (~G905 (CL:CDR ~G283))))) (~G904 (CL:CAR ~G283))))) (~G903 (CL:CDR ~G282))))) (~G902 (CL:CAR ~G282))))) (~G901 (CL:CDR ~G281))))) (~G900 (READ-TOKEN STR)))))) (~G881 (STREAM-LOCATION-ID LOC))))) (~G880 (STREAM-LOCATION-COLUMN LOC))))) (~G879 (STREAM-LOCATION-LINE LOC))))) (~G878 (STREAM-INPUT-LOCATION STR))))))
  -(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G907 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G908 (~G242) (CL:COND (~G242 ~G242) (T (EQ X :CURLY-BRACKET-CLOSE))))) (~G908 (EQ X :SQUARE-BRACKET-CLOSE))))))) (~G907 (EQ X :BRACKET-CLOSE))))))
  -(CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G909 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((CONS? PKG) (LIST-STRING PKG)) (T PKG))))))) (~G909 (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 ((~G910 (!) (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)))) (~G910 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G911 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G911 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G912 (~G227) (CL:COND (~G227 ~G227) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G912 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G913 (~G228) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G228)) (~G913 (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 ((~G914 (~G229) (CL:COND (~G229 ~G229) (T 0)))) (~G914 (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 ((~G915 (~G164) (CL:LABELS ((~G916 (S) (CL:LABELS ((~G917 (~G165) (CL:COND (~G164 ~G165) (T (GET-STREAM-STRING S))))) (~G917 (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))))) (~G916 (DEFAULT-STREAM ~G164))))) (~G915 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 ((~G918 (~G151) (CL:COND (~G151 (CL:PROGN (CL:LABELS ((~G919 (~G153) (CL:BLOCK NIL (CL:LABELS ((~G920 (~G152) (CL:TAGBODY ~G154 (CL:COND ((== ~G152 ~G153) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G921 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G921 (ELT ~G151 ~G152))) (CL:SETQ ~G152 (NUMBER+ 1 ~G152)) (CL:GO ~G154)))) (~G920 0))))) (~G919 (CL:LENGTH ~G151)))))))) (~G918 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:LABELS ((~G922 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G922 (READ-CHAR STR))))) (LIST-STRING (F))))))
  +(CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G884 (LOC) (CL:LABELS ((~G885 (LINE) (CL:LABELS ((~G886 (COLUMN) (CL:LABELS ((~G887 (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 ((~G888 (~G269) (CL:COND ((EQUAL ~G269 :BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQUAL ~G269 :SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQUAL ~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))))))) (~G888 TOKEN)) (CL:LABELS ((~G889 (!) (CL:COND (! (CL:LABELS ((~G890 (~G271) (CL:LABELS ((~G891 (~G272) (CL:LABELS ((~G892 (TOKEN) (CL:LABELS ((~G893 (~G273) (CL:LABELS ((~G894 (PKG) (CL:LABELS ((~G895 (~G274) (CL:LABELS ((~G896 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G897 (X) (CL:LABELS ((~G898 (~G276) (CL:LABELS ((~G899 (~G277) (CL:LABELS ((~G900 (TOKEN) (CL:LABELS ((~G901 (~G278) (CL:LABELS ((~G902 (PKG) (CL:LABELS ((~G903 (~G279) (CL:LABELS ((~G904 (SYM) (CL:LABELS ((~G905 (~G270) (CL:COND (~G270 ~G270) (T (ERR "Only one value allowed after dotted cons."))))) (~G905 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G904 (CL:CAR ~G279))))) (~G903 (CL:CDR ~G278))))) (~G902 (CL:CAR ~G278))))) (~G901 (CL:CDR ~G277))))) (~G900 (CL:CAR ~G277))))) (~G899 (CL:CDR ~G276))))) (~G898 (READ-TOKEN STR))))) (~G897 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G896 (CL:CAR ~G274))))) (~G895 (CL:CDR ~G273))))) (~G894 (CL:CAR ~G273))))) (~G893 (CL:CDR ~G272))))) (~G892 (CL:CAR ~G272))))) (~G891 (CL:CDR ~G271))))) (~G890 !))) (T (ERR "Closing bracket missing."))))) (~G889 (READ-TOKEN STR))))))))) (CL:LABELS ((~G906 (~G281) (CL:LABELS ((~G907 (~G282) (CL:LABELS ((~G908 (TOKEN) (CL:LABELS ((~G909 (~G283) (CL:LABELS ((~G910 (PKG) (CL:LABELS ((~G911 (~G284) (CL:LABELS ((~G912 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G912 (CL:CAR ~G284))))) (~G911 (CL:CDR ~G283))))) (~G910 (CL:CAR ~G283))))) (~G909 (CL:CDR ~G282))))) (~G908 (CL:CAR ~G282))))) (~G907 (CL:CDR ~G281))))) (~G906 (READ-TOKEN STR)))))) (~G887 (STREAM-LOCATION-ID LOC))))) (~G886 (STREAM-LOCATION-COLUMN LOC))))) (~G885 (STREAM-LOCATION-LINE LOC))))) (~G884 (STREAM-INPUT-LOCATION STR))))))
  +(CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G913 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G914 (~G242) (CL:COND (~G242 ~G242) (T (EQ X :CURLY-BRACKET-CLOSE))))) (~G914 (EQ X :SQUARE-BRACKET-CLOSE))))))) (~G913 (EQ X :BRACKET-CLOSE))))))
  +(CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G915 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (CL:LAST !)))))) (READ-SLOT-VALUE !)) (T (MAKE-SYMBOL (LIST-STRING SYM) (CL:COND ((NOT PKG) NIL) ((CONS? PKG) (LIST-STRING PKG)) (T PKG))))))) (~G915 (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 ((~G916 (!) (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)))) (~G916 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G917 (!) (CL:COND ((HEX-DIGIT-CHAR? !) !)))) (~G917 (CHAR-UPCASE (PEEK-CHAR STR)))))))))) (CL:LABELS ((~G918 (~G227) (CL:COND (~G227 ~G227) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G918 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G919 (~G228) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G228)) (~G919 (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 ((~G920 (~G229) (CL:COND (~G229 ~G229) (T 0)))) (~G920 (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 ((~G921 (~G164) (CL:LABELS ((~G922 (S) (CL:LABELS ((~G923 (~G165) (CL:COND (~G164 ~G165) (T (GET-STREAM-STRING S))))) (~G923 (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))))) (~G922 (DEFAULT-STREAM ~G164))))) (~G921 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 ((~G924 (~G151) (CL:COND (~G151 (CL:PROGN (CL:LABELS ((~G925 (~G153) (CL:BLOCK NIL (CL:LABELS ((~G926 (~G152) (CL:TAGBODY ~G154 (CL:COND ((== ~G152 ~G153) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G927 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G927 (ELT ~G151 ~G152))) (CL:SETQ ~G152 (NUMBER+ 1 ~G152)) (CL:GO ~G154)))) (~G926 0))))) (~G925 (CL:LENGTH ~G151)))))))) (~G924 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:LABELS ((~G928 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G928 (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))))))))
  -(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G923 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G923 (READ-CHAR STR))))))
  -(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 ((~G924 (!) (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) !)) (~G924 NIL)))))
  +(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G929 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G929 (READ-CHAR STR))))))
  +(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 ((~G930 (!) (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) !)) (~G930 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 ((EQL #\. (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 ((EQL #\. (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 ((~G925 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G926 (L) (CL:LABELS ((~G927 (S) (CL:LABELS ((~G928 (~G48) (CL:BLOCK NIL (CL:LABELS ((~G929 (X) (CL:TAGBODY ~G49 (CL:COND ((== X ~G48) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G49)))) (~G929 0))))) (~G928 L)))) (~G927 (FUNCALL MAKER L))))) (~G926 (- END START)))))))) (~G925 (CL:LENGTH SEQ)))))))))
  -(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G930 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G931 (L) (CL:LABELS ((~G932 (S) (CL:LABELS ((~G933 (~G44) (CL:BLOCK NIL (CL:LABELS ((~G934 (X) (CL:TAGBODY ~G45 (CL:COND ((== X ~G44) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (STRING-CONCAT S (STRING (ELT SEQ (NUMBER+ START X)))))) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G45)))) (~G934 0))))) (~G933 L)))) (~G932 (CL:MAKE-STRING 0))))) (~G931 (- END START)))))))) (~G930 (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 ((~G935 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G935 START)))) (CL:LABELS ((~G936 (Q) (CL:LABELS ((~G937 (LEN) (CL:LABELS ((~G938 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G47 (CL:COND ((NOT (CL:COND (LST (< 0 LEN)))) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (CL:CAR LST)) (CL:PROGN (CL:SETQ LEN (- LEN 1))) (CL:PROGN (CL:SETQ LST (CL:CDR LST))) (CL:GO ~G47)))))) (~G938 (CL:NTHCDR START SEQ))))) (~G937 (- END START))))) (~G936 (MAKE-QUEUE)))))))))
  +(CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G931 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G932 (L) (CL:LABELS ((~G933 (S) (CL:LABELS ((~G934 (~G48) (CL:BLOCK NIL (CL:LABELS ((~G935 (X) (CL:TAGBODY ~G49 (CL:COND ((== X ~G48) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G49)))) (~G935 0))))) (~G934 L)))) (~G933 (FUNCALL MAKER L))))) (~G932 (- END START)))))))) (~G931 (CL:LENGTH SEQ)))))))))
  +(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G936 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G937 (L) (CL:LABELS ((~G938 (S) (CL:LABELS ((~G939 (~G44) (CL:BLOCK NIL (CL:LABELS ((~G940 (X) (CL:TAGBODY ~G45 (CL:COND ((== X ~G44) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (STRING-CONCAT S (STRING (ELT SEQ (NUMBER+ START X)))))) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G45)))) (~G940 0))))) (~G939 L)))) (~G938 (CL:MAKE-STRING 0))))) (~G937 (- END START)))))))) (~G936 (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 ((~G941 (~G46) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G46)))) (~G941 START)))) (CL:LABELS ((~G942 (Q) (CL:LABELS ((~G943 (LEN) (CL:LABELS ((~G944 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G47 (CL:COND ((NOT (CL:COND (LST (< 0 LEN)))) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (CL:CAR LST)) (CL:PROGN (CL:SETQ LEN (- LEN 1))) (CL:PROGN (CL:SETQ LST (CL:CDR LST))) (CL:GO ~G47)))))) (~G944 (CL:NTHCDR START SEQ))))) (~G943 (- END START))))) (~G942 (MAKE-QUEUE)))))))))
   (CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
   (CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
   (CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  
positive.code: ; tré Common Lisp core, generated by 'makefiles/boot-common.lisp'.
  (declaim #+sbcl(sb-ext:muffle-conditions compiler-note style-warning))
  (DEFPACKAGE "TRE-CORE" (:EXPORT "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "BACKQUOTE" "QUASIQUOTE" "QUASIQUOTE-SPLICE" "SQUARE" "CURLY" "ACCENT-CIRCONFLEX" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK" "POW" "CHARACTER>" "CHARACTER<" "CHARACTER==" "NUMBER>" "NUMBER<" "NUMBER/" "NUMBER*" "NUMBER-" "NUMBER+" "NUMBER==" "%/" "%*" ">=" "<=" ">" "<" "==" "/" "*" "-" "%CODE-CHAR" "INTEGER" "CHARACTER?" "NUMBER?" "ARRAY?" "STRING?" "FUNCTION?" "SYMBOL?" "CONS?" "NANOTIME" "UNIX-SH-RM" "UNIX-SH-MKDIR" "UNIX-SH-CP" "SH" "=-SYMBOL-FUNCTION" "SYMBOL-PACKAGE" "SYMBOL-FUNCTION" "SYMBOL-VALUE" "SYMBOL-NAME" "MAKE-SYMBOL" "LIST-STRING" "STRING==" "STRING" "STRING-CONCAT" "%SET-ELT" "ELT" "EQL" "EQ" "NOT" "<<" ">>" "BIT-XOR" "BIT-OR" "BIT-AND" "CODE-CHAR" "NANOTIME" "QUIT" "MACROEXPAND" "MACROEXPAND-1" "%%MACRO?" "%%MACROCALL" "MACRO?" "LOAD" "APPEND" "FILTER" "%START-CORE" "SYS-IMAGE-CREATE" "HASHKEYS" "COPY-HASH-TABLE" "HREMOVE" "=-HREF" "HREF" "HASH-TABLE?" "MAKE-HASH-TABLE" "FUNCTION-BYTECODE" "=-FUNCTION-SOURCE" "FUNCTION-SOURCE" "FUNCTION-NATIVE" "FILE-EXISTS?" "%READ-CHAR" "%FCLOSE" "%FOPEN" "%FORCE-OUTPUT" "%PRINC" "EVAL" "%ERROR" "ENV-LOAD" "=-AREF" "MAKE-ARRAY" "BUILTIN?" "%DEFUN-QUIET" "%DEFUN" "%DEFVAR" "%DEFMACRO" "?" "*UNIVERSE*" "*VARIABLES*" "*FUNCTIONS*" "*ENVIRONMENT-PATH*" "*ENVIRONMENT-FILENAMES*" "*MACROEXPAND*" "*QUASIQUOTE-EXPAND*" "*DOT-EXPAND*" "*PACKAGE*" "*KEYWORD-PACKAGE*" "*POINTER-SIZE*" "*LAUNCHFILE*" "*ASSERT?*" "*TARGETS*" "*ENDIANESS*" "*CPU-TYPE*" "*LIBC-PATH*" "*RAND-MAX*" "*EVAL*" "CONS?" "SYMBOL?" "FUNCTION?" "STRING?" "ARRAY?" "NUMBER?" "CHARACTER?" "INTEGER" "%CODE-CHAR" "-" "*" "/" "==" "<" ">" "<=" ">=" "%*" "%/" "NUMBER==" "NUMBER+" "NUMBER-" "NUMBER*" "NUMBER/" "NUMBER<" "NUMBER>" "CHARACTER==" "CHARACTER<" "CHARACTER>" "POW") (:IMPORT-FROM "CL" "FORMAT" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "SLOT-VALUE" "&REST" "&BODY" "&OPTIONAL" "&KEY" "ATOM" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LIST" "LAST" "COPY-LIST" "NTHCDR" "NTH" "MAPCAR" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "ATAN" "EXP" "ROUND" "FLOOR" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "BREAK"))
  (DEFPACKAGE "TRE" (:USE "TRE-CORE"))
  (CL:IN-PACKAGE :TRE-CORE)
  "Section CL-CORE"
  
negative.code: (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CHAR>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
  (CL:PROGN (CL:DEFUN POW (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:EXPT) X)) (CL:SETF (CL:GETHASH 'POW *BUILTIN-ATOMS*) (CL:FUNCTION POW)))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G819 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G819 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN NUMBER-DIGIT (X) (CL:BLOCK NUMBER-DIGIT (CL:BLOCK NIL (CODE-CHAR (+ X (CL:CHAR-CODE #\0))))))
  (CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- (CL:CHAR-CODE X) (CL:CHAR-CODE #\0)))))
  