anchor.diff:  (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 =-FORMAT-INFO-PROCESSED-ARGS (VAL ARR) (CL:BLOCK =-FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
   (CL:DEFUN FORMAT-INFO-PROCESSED-ARGS (ARR) (CL:BLOCK FORMAT-INFO-PROCESSED-ARGS (CL:BLOCK NIL (CL:AREF ARR 5))))
  -(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:LABELS ((~G881 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G881 (CL:CAR LSTS))))))))
  +(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:LABELS ((~G890 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G890 (CL:CAR LSTS))))))))
   (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (CL:COND ((NUMBER? X) (== 0 X))))))
  -(CL:DEFUN %FORMAT-DIRECTIVE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE (CL:BLOCK NIL (CL:PROGN (=-FORMAT-INFO-PROCESSED-ARGS (NUMBER+ (FORMAT-INFO-PROCESSED-ARGS INF) 1) INF)) (CL:LABELS ((~G882 (~G304) (CL:COND ((EQL ~G304 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((EQL ~G304 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((EQL ~G304 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) ((EQL ~G304 #\L) (%FORMAT-DIRECTIVE-FRESH-LINE INF (CL:CDR TXT) ARGS)) ((EQL ~G304 #\~) (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G882 (CHAR-UPCASE (CL:CAR TXT)))))))
  +(CL:DEFUN %FORMAT-DIRECTIVE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE (CL:BLOCK NIL (CL:PROGN (=-FORMAT-INFO-PROCESSED-ARGS (NUMBER+ (FORMAT-INFO-PROCESSED-ARGS INF) 1) INF)) (CL:LABELS ((~G891 (~G305) (CL:COND ((EQL ~G305 #\%) (%FORMAT-DIRECTIVE-EOL INF (CL:CDR TXT) ARGS)) ((EQL ~G305 #\A) (%FORMAT-DIRECTIVE-PLACEHOLDER INF (CL:CDR TXT) ARGS)) ((EQL ~G305 #\F) (%FORMAT-DIRECTIVE-FORCE-OUTPUT INF (CL:CDR TXT) ARGS)) ((EQL ~G305 #\L) (%FORMAT-DIRECTIVE-FRESH-LINE INF (CL:CDR TXT) ARGS)) ((EQL ~G305 #\~) (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))) (T (%FORMAT-DIRECTIVE-TILDE INF TXT ARGS))))) (~G891 (CHAR-UPCASE (CL:CAR TXT)))))))
   (CL:DEFUN FORMAT-INFO-STREAM (ARR) (CL:BLOCK FORMAT-INFO-STREAM (CL:BLOCK NIL (CL:AREF ARR 2))))
   (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
   (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
  
positive.code: (CL:DEFVAR *DOT-EXPAND*)
  (CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
  NIL
  (CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G745 (~G719) (CL:COND (~G719 ~G719) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G745 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
  (CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-ARRAY)))
  (CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) (CL:FUNCTION =-AREF)))
  (CL:DEFVAR *ENVIRONMENT-PATH*)
  (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
  (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&REST TARGETS) (PRINT-DEFINITION `(ENV-LOAD ,PATHNAME ,@TARGETS)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGETS) *ENVIRONMENT-FILENAMES*)) (CL:COND ((CL:LABELS ((~G746 (~G720) (CL:COND (~G720 ~G720) (T (MEMBER :CL TARGETS))))) (~G746 (NOT TARGETS))) (CL:PROGN (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME)))))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
  (CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G747 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADR (CL:CAR X))))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G747 (GENSYM))))
  (CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G748 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G748 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  (CL:DEFUN LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
  (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (DYNAMIC-MAP (CL:FUNCTION MAKE-LAMBDAS) X))))
  (CL:PROGN (CL:DEFUN %ERROR (MSG) (CL:BREAK (NEUTRALIZE-FORMAT-STRING MSG))) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) (CL:FUNCTION %ERROR)))
  (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
  (CL:DEFVAR *EVAL*)
  (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
  (CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G749 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G750 (~G722) (CL:COND (~G722 (CL:PROGN (CL:LABELS ((~G751 (~G724) (CL:BLOCK NIL (CL:LABELS ((~G752 (~G723) (CL:TAGBODY ~G725 (CL:COND ((== ~G723 ~G724) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G753 (I) (%PRINC I !))) (~G753 (ELT ~G722 ~G723))) (CL:SETQ ~G723 (NUMBER+ 1 ~G723)) (CL:GO ~G725)))) (~G752 0))))) (~G751 (INTEGER (CL:LENGTH ~G722))))))))) (~G750 X))) (T (CL:PRINC X !))))) (~G749 (CL:LABELS ((~G754 (~G721) (CL:COND (~G721 ~G721) (T CL:*STANDARD-OUTPUT*)))) (~G754 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
  (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
  (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
  (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
  (CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G755 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G755 (CL:READ-BYTE (CL:LABELS ((~G756 (~G726) (CL:COND (~G726 ~G726) (T CL:*STANDARD-INPUT*)))) (~G756 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
  (CL:PROGN (CL:DEFUN FILE-EXISTS? (PATHNAME) (CL:COND ((CL:PROBE-FILE PATHNAME) T))) (CL:SETF (CL:GETHASH 'FILE-EXISTS? *BUILTIN-ATOMS*) (CL:FUNCTION FILE-EXISTS?)))
  (CL:DEFVAR *FUNCTIONS*)
  (CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST (CL:FUNCTION CL:EQ)))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-SOURCE)))
  (CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (ERROR "Can't set function source in the Common Lisp core.")) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION =-FUNCTION-SOURCE)))
  (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-BYTECODE)))
  (CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G757 (~G727) (CL:COND (~G727 ~G727) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G757 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
  (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) (CL:FUNCTION HASH-TABLE?)))
  (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) (CL:FUNCTION HREF)))
  (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) (CL:FUNCTION =-HREF)))
  (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) (CL:FUNCTION HREMOVE)))
  (CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G758 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G758 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
  (CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G759 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G759 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
  (CL:PROGN (CL:DEFUN SYS-IMAGE-CREATE (PATHNAME FUN) (SB-EXT:SAVE-LISP-AND-DIE PATHNAME :TOPLEVEL (CL:LAMBDA NIL (CL:FUNCALL FUN)))) (CL:SETF (CL:GETHASH 'SYS-IMAGE-CREATE *BUILTIN-ATOMS*) (CL:FUNCTION SYS-IMAGE-CREATE)))
  (CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G760 (~G728) (CL:COND (~G728 ~G728) (T NIL)))) (~G760 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
  (CL:PROGN (CL:DEFUN FILTER (FUN X) (CL:MAPCAR FUN X)) (CL:SETF (CL:GETHASH 'FILTER *BUILTIN-ATOMS*) (CL:FUNCTION FILTER)))
  (CL:PROGN (CL:DEFUN APPEND (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:NCONC) (CL:MAPCAR (CL:FUNCTION CL:COPY-LIST) X))) (CL:SETF (CL:GETHASH 'APPEND *BUILTIN-ATOMS*) (CL:FUNCTION APPEND)))
  (CL:DEFUN %LOAD-R (S) (CL:COND ((PEEK-CHAR S) (CL:PROGN (CL:CONS (READ S) (%LOAD-R S))))))
  (CL:DEFUN %EXPAND (X) (CL:LABELS ((~G761 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G761 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
  (CL:PROGN (CL:DEFUN LOAD (PATHNAME) (PRINT-DEFINITION `(LOAD ,PATHNAME)) (CL:BLOCK NIL (CL:LABELS ((~G762 (~G732) (CL:LABELS ((~G763 (I) (CL:TAGBODY ~G730 (CL:COND ((NOT ~G732) (CL:GO ~G731))) (CL:SETQ I (CL:CAR ~G732)) (EVAL (%EXPAND I)) (CL:SETQ ~G732 (CL:CDR ~G732)) (CL:GO ~G730) ~G731 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G763 NIL)))) (~G762 (CL:LABELS ((~G764 (S) (CL:LABELS ((~G765 (~G729) (CLOSE S) ~G729)) (~G765 (CL:BLOCK NIL (%LOAD-R S)))))) (~G764 (OPEN PATHNAME :DIRECTION 'INPUT))))))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
  (CL:DEFUN ENV-MACROS NIL (SYMBOL-VALUE (TRE-SYMBOL '*MACROS*)))
  (CL:PROGN (CL:DEFUN MACRO? (X) (CL:RASSOC X (ENV-MACROS) :TEST (CL:FUNCTION EQ))) (CL:SETF (CL:GETHASH 'MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION MACRO?)))
  (CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G766 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G766 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
  (CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G767 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G767 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
  (CL:DEFVAR *MACROEXPAND*)
  (CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G768 (!) (CL:COND (! (CL:APPLY ! (LIST X))) (T X)))) (~G768 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
  (CL:PROGN (CL:DEFUN MACROEXPAND (X) (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (MACROEXPAND X))))) (F X (MACROEXPAND-1 X)))) (CL:SETF (CL:GETHASH 'MACROEXPAND *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND)))
  (CL:PROGN (CL:DEFUN QUIT (CL:&OPTIONAL EXIT-CODE) (SB-EXT:QUIT :UNIX-STATUS EXIT-CODE)) (CL:SETF (CL:GETHASH 'QUIT *BUILTIN-ATOMS*) (CL:FUNCTION QUIT)))
  (CL:PROGN (CL:DEFUN CODE-CHAR (X) (CL:COND ((CL:CHARACTERP X) X) (T (CL:CODE-CHAR X)))) (CL:SETF (CL:GETHASH 'CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CODE-CHAR)))
  (CL:DEFUN BITS-INTEGER (BITS) (CL:REDUCE (CL:LAMBDA (A B) (+ (* A 2) B)) BITS))
  (CL:DEFUN NUMBER (X) (CL:COND ((CHARACTER? X) (CL:CHAR-CODE X)) (T X)))
  (CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G769 (!) (CL:LABELS ((~G770 (L) (CL:LABELS ((~G771 (~G733) (CL:BLOCK NIL (CL:LABELS ((~G772 (I) (CL:TAGBODY ~G734 (CL:COND ((== I ~G733) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (NUMBER+ 1 I)) (CL:GO ~G734)))) (~G772 0))))) (~G771 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G770 NIL)))) (~G769 (NUMBER X))))
  (CL:PROGN (CL:DEFUN BIT-AND (A B) (BITS-INTEGER (CL:BIT-AND (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-AND *BUILTIN-ATOMS*) (CL:FUNCTION BIT-AND)))
  (CL:PROGN (CL:DEFUN BIT-OR (A B) (BITS-INTEGER (CL:BIT-IOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-OR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-OR)))
  (CL:PROGN (CL:DEFUN BIT-XOR (A B) (BITS-INTEGER (CL:BIT-XOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-XOR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-XOR)))
  (CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G773 (~G735) (CL:BLOCK NIL (CL:LABELS ((~G774 (N) (CL:TAGBODY ~G736 (CL:COND ((== N ~G735) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE X 2) (CL:PROGN (CL:SETQ X I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G736)))) (~G774 0))))) (~G773 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G775 (~G737) (CL:BLOCK NIL (CL:LABELS ((~G776 (N) (CL:TAGBODY ~G738 (CL:COND ((== N ~G737) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:PROGN (CL:SETQ X (* X 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G738)))) (~G776 0))))) (~G775 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
  (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY (CL:FUNCTION CL:NOT) X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) (CL:FUNCTION NOT)))
  (CL:PROGN (CL:DEFUN EQ (A B) (CL:EQ A B)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
  (CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G777 (~G739) (CL:COND (~G739 ~G739) (T (CL:COND ((CL:COND ((CL:CHARACTERP A) (CL:CHARACTERP B))) (CL:= (CL:CHAR-CODE A) (CL:CHAR-CODE B))) ((CL:COND ((NOT (CL:CHARACTERP A) (CL:CHARACTERP B)) (CL:COND ((NUMBER? A) (NUMBER? B))))) (CL:= A B)) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((EQL (CL:CAR A) (CL:CAR B)) (EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B))))))) (~G777 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  (CL:PROGN (CL:DEFUN STRING-CONCAT (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CONCATENATE) 'CL:STRING X)) (CL:SETF (CL:GETHASH 'STRING-CONCAT *BUILTIN-ATOMS*) (CL:FUNCTION STRING-CONCAT)))
  (CL:PROGN (CL:DEFUN STRING (X) (CL:COND ((CL:NUMBERP X) (CL:FORMAT NIL "~A" X)) (T (CL:STRING X)))) (CL:SETF (CL:GETHASH 'STRING *BUILTIN-ATOMS*) (CL:FUNCTION STRING)))
  (CL:PROGN (CL:DEFUN STRING== (A B) (CL:STRING= A B)) (CL:SETF (CL:GETHASH 'STRING== *BUILTIN-ATOMS*) (CL:FUNCTION STRING==)))
  (CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:LABELS ((~G778 (~G740) (CL:COND (~G740 ~G740) (T (ERROR "List expected instead of ~A." X))))) (~G778 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
  (CL:PROGN (CL:DEFUN %ELT-STRING (OBJ IDX) (CL:ELT OBJ IDX)) (CL:SETF (CL:GETHASH '%ELT-STRING *BUILTIN-ATOMS*) (CL:FUNCTION %ELT-STRING)))
  (CL:DEFVAR *SPECIAL-FORMS*)
  (CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G779 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G779 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
  (CL:DEFUN SPECIAL-%%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ)))))))
  (CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G780 (~G741) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G781 (~G742) (CL:PROGN (CL:SETQ *MACRO?* ~G741)) ~G742)) (~G781 (CL:PROGN (CL:LABELS ((~G782 (~G743) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G783 (~G744) (CL:PROGN (CL:SETQ *MACROCALL* ~G743)) ~G744)) (~G783 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G782 *MACROCALL*))))))) (~G780 *MACRO?*)))
  (CL:DEFUN MAKE-%FN-QUIET (NAME ARGS BODY) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',(CL:CONS ARGS BODY)) *FUNCTIONS*) (CL:DEFUN ,NAME ,ARGS ,@BODY)))
  NIL
  NIL
  
negative.code: (CL:DEFUN %GET-PRINTER-ARGUMENT-DEFINITION (X) (CL:BLOCK %GET-PRINTER-ARGUMENT-DEFINITION (CL:BLOCK NIL (HREF *PRINTER-ARGUMENT-DEFINITIONS* X))))
  (CL:DEFUN MAKE-KEYWORD (X) (CL:BLOCK MAKE-KEYWORD (CL:BLOCK NIL (CL:COND (X (MAKE-SYMBOL (CL:COND ((SYMBOL? X) (SYMBOL-NAME X)) (T X)) *KEYWORD-PACKAGE*))))))
  (CL:DEFUN %PRINT-GET-ARGS (ARGS DEF) (CL:BLOCK %PRINT-GET-ARGS (CL:BLOCK NIL (ARGUMENT-EXPAND 'CL:PRINT DEF ARGS :CONCATENATE-SUBLISTS? NIL :BREAK-ON-ERRORS? NIL))))
  (CL:DEFUN %PRINT-GAP (STR) (CL:BLOCK %PRINT-GAP (CL:BLOCK NIL (CL:LABELS ((~G791 (~G187) (CL:COND (~G187 ~G187) (T (PRINC " " STR))))) (~G791 (FRESH-LINE? STR))))))
  (CL:DEFUN INVISIBLE-PACKAGE? (X) (CL:BLOCK INVISIBLE-PACKAGE? (CL:BLOCK NIL (CL:LABELS ((~G792 (!) (SOME (CL:LAMBDA (_) (CL:BLOCK NIL (STRING== ! _))) *INVISIBLE-PACKAGE-NAMES*))) (~G792 (CL:PACKAGE-NAME X))))))
  (CL:DEFUN ABBREVIATED-PACKAGE-NAME (X) (CL:BLOCK ABBREVIATED-PACKAGE-NAME (CL:BLOCK NIL (CL:COND ((STRING== "COMMON-LISP" X) "CL") (T X)))))
  (CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G793 (~G207) (CL:LABELS ((~G794 (I) (CL:TAGBODY ~G205 (CL:COND ((NOT ~G207) (CL:GO ~G206))) (CL:SETQ I (CL:CAR ~G207)) (CL:COND ((EQL I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G207 (CL:CDR ~G207)) (CL:GO ~G205) ~G206 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G794 NIL)))) (~G793 (STRING-LIST X)))) (PRINC #\| STR))))
  (CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G795 (~G208) (CL:COND (~G208 ~G208) (T (LOWER-CASE? X))))) (~G795 (EQL #\| X))))))
  (CL:DEFUN SOME (PRED CL:&REST SEQS) (CL:BLOCK SOME (CL:BLOCK NIL (FIND-IF PRED (CL:APPLY (CL:FUNCTION APPEND) SEQS)))))
  (CL:DEFUN %PRINT-REST (X STR INFO) (CL:BLOCK %PRINT-REST (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:PROGN (%PRINT-GAP STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO))) (T (CL:PROGN (PRINC " . " STR) (%LATE-PRINT X STR INFO))))))))))
  (CL:DEFUN %PRINT-CALL (X ARGDEF STR INFO) (CL:BLOCK %PRINT-CALL (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G796 (EXPANDED) (CL:COND ((EQ EXPANDED 'ERROR) (%PRINT-REST (CL:CDR X) STR INFO)) (T (CL:BLOCK NIL (CL:LABELS ((~G797 (~G200) (CL:LABELS ((~G798 (I) (CL:TAGBODY ~G198 (CL:COND ((NOT ~G200) (CL:GO ~G199))) (CL:SETQ I (CL:CAR ~G200)) (%PRINT-GAP STR) (CL:COND ((CL:COND ((%BODY? (CL:CDR I)) (CL:CDR (CL:CDR I)))) (CL:PROGN (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))) (%PRINT-BODY (CL:CDR (CL:CDR I)) STR INFO))) ((%REST? (CL:CDR I)) (%PRINT-REST (CL:CDR (CL:CDR I)) STR INFO)) ((%KEY? (CL:CDR I)) (CL:PROGN (%PRINT-SYMBOL (MAKE-KEYWORD (CL:CAR I)) STR INFO) (PRINC " " STR) (%LATE-PRINT (CL:CDR (CL:CDR I)) STR INFO))) (T (CL:LABELS ((~G799 (~G196) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G800 (~G197) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G196)) ~G197)) (~G800 (CL:PROGN (%LATE-PRINT (CL:CDR I) STR INFO)))))) (~G799 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G200 (CL:CDR ~G200)) (CL:GO ~G198) ~G199 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G798 NIL)))) (~G797 EXPANDED))))))) (~G796 (%PRINT-GET-ARGS (CL:CDR X) ARGDEF))) (PRINC ")" STR) (CL:LABELS ((~G801 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G801 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))
  (CL:DEFUN %PRINT-CALL? (X INFO) (CL:BLOCK %PRINT-CALL? (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((CONS? X) (CL:COND ((CL:CAR X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:COND ((LIST? (CL:CDR X)) (CL:LABELS ((~G802 (~G201) (CL:COND (~G201 ~G201) (T (CL:COND ((NOT (BUILTIN? (CL:CAR X))) (CL:PROGN (CL:COND ((FUNCTION? (SYMBOL-FUNCTION (CL:CAR X))) (FUNCTION-ARGUMENTS (CL:CAR X))))))))))) (~G802 (%GET-PRINTER-ARGUMENT-DEFINITION (CL:CAR X)))))))))))))))))
  (CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:LABELS ((~G803 (!) (CL:COND (! (CL:COND ((FUNCTION? !) (FUNCALL ! X STR INFO)) (T (%PRINT-CALL X ! STR INFO)))) (T (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO) (PRINC ")" STR) (CL:LABELS ((~G804 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G804 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))) (~G803 (%PRINT-CALL? X INFO))))))
  (CL:DEFUN %PRINT-ABBREVIATION (ABBREVIATION X STR INFO) (CL:BLOCK %PRINT-ABBREVIATION (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC (CL:CAR (CL:CDR ABBREVIATION)) STR) (%LATE-PRINT (CL:CAR (CL:CDR X)) STR INFO)))))
  (CL:DEFUN %PRINT-SYMBOL-COMPONENT (X STR) (CL:BLOCK %PRINT-SYMBOL-COMPONENT (CL:BLOCK NIL (CL:COND ((SOME (CL:FUNCTION SYMBOL-CHAR-NEEDS-ESCAPING?) (STRING-LIST X)) (%PRINT-ESCAPED-SYMBOL X STR)) (T (PRINC X STR))))))
  (CL:DEFUN %PRINT-SYMBOL-PACKAGE (NAME STR) (CL:BLOCK %PRINT-SYMBOL-PACKAGE (CL:BLOCK NIL (%PRINT-SYMBOL-COMPONENT (ABBREVIATED-PACKAGE-NAME NAME) STR))))
  (CL:DEFUN INVISIBLE-PACKAGE-NAME? (X) (CL:BLOCK INVISIBLE-PACKAGE-NAME? (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G805 (~G209) (CL:COND (~G209 ~G209) (T (CL:LABELS ((~G806 (~G210) (CL:COND (~G210 ~G210) (T *ALWAYS-PRINT-PACKAGE-NAMES?*)))) (~G806 (EQ T X))))))) (~G805 (NOT X)))) (CL:PROGN (INVISIBLE-PACKAGE? (SYMBOL-PACKAGE X))))))))
  (CL:DEFUN FUNCTION-BODY (FUN) (CL:BLOCK FUNCTION-BODY (CL:BLOCK NIL (CL:COND ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 1)) (T (CL:CDR (FUNCTION-SOURCE FUN)))))))
  (CL:DEFUN FUNCTION-ARGUMENTS (FUN) (CL:BLOCK FUNCTION-ARGUMENTS (CL:BLOCK NIL (CL:COND ((BUILTIN? FUN) (CL:CONS 'CL:&REST (CL:CONS 'ARGS-TO-BUILTIN NIL))) ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 0)) (T (CL:CAR (FUNCTION-SOURCE FUN)))))))
  (CL:DEFUN RANGE? (X BOTTOM TOP) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X BOTTOM) (<= X TOP))))))
  (CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN =-PRINT-INFO-INDENTATION (VAL ARR) (CL:BLOCK =-PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN %BODY-INDENTATION (INFO) (CL:BLOCK %BODY-INDENTATION (CL:BLOCK NIL (CL:LABELS ((~G807 (~G190) (CL:COND (~G190 ~G190) (T 1)))) (~G807 (CL:CAR (PRINT-INFO-COLUMNS INFO)))))))
  (CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN %PRINT-OBJECT (X STR INFO) (CL:BLOCK %PRINT-OBJECT (CL:BLOCK NIL)))
  (CL:DEFUN %PRINT-FUNCTION (X STR INFO) (CL:BLOCK %PRINT-FUNCTION (CL:BLOCK NIL (PRINC "#'" STR) (%LATE-PRINT (CL:CONS (FUNCTION-ARGUMENTS X) (FUNCTION-BODY X)) STR INFO))))
  (CL:DEFUN %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (CL:LABELS ((~G808 (~G212) (CL:COND (~G212 (CL:PROGN (CL:LABELS ((~G809 (~G214) (CL:BLOCK NIL (CL:LABELS ((~G810 (~G213) (CL:TAGBODY ~G215 (CL:COND ((== ~G213 ~G214) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G811 (I) (CL:LABELS ((~G812 (~G216) (CL:COND (~G216 ~G216) (T (PRINC #\  STR))))) (~G812 (ZERO? I))) (%LATE-PRINT I STR INFO))) (~G811 (CL:AREF ~G212 ~G213))) (CL:SETQ ~G213 (NUMBER+ 1 ~G213)) (CL:GO ~G215)))) (~G810 0))))) (~G809 (INTEGER (CL:LENGTH ~G212))))))))) (~G808 X)) (PRINC ")" STR) (CL:LABELS ((~G813 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G813 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))
  (CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G814 (~G204) (CL:LABELS ((~G815 (I) (CL:TAGBODY ~G202 (CL:COND ((NOT ~G204) (CL:GO ~G203))) (CL:SETQ I (CL:CAR ~G204)) (CL:COND ((EQL I #\") (PRINC "\\\"" STR)) ((EQL I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G204 (CL:CDR ~G204)) (CL:GO ~G202) ~G203 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G815 NIL)))) (~G814 (STRING-LIST X)))) (PRINC #\" STR))))
  (CL:DEFUN %PRINT-CHARACTER (X STR) (CL:BLOCK %PRINT-CHARACTER (CL:BLOCK NIL (PRINC "#\\" STR) (PRINC X STR))))
  (CL:DEFUN %PRINT-SYMBOL (X STR INFO) (CL:BLOCK %PRINT-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G816 (!) (CL:COND (! (CL:PROGN (CL:COND ((NOT (INVISIBLE-PACKAGE-NAME? X)) (CL:PROGN (CL:LABELS ((~G817 (~G211) (CL:COND (~G211 ~G211) (T (%PRINT-SYMBOL-PACKAGE (CL:PACKAGE-NAME !) STR))))) (~G817 (KEYWORD? X))) (PRINC #\: STR))))))))) (~G816 (CL:COND (X (CL:COND ((NOT (EQ T X)) (SYMBOL-PACKAGE X))))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
  (CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G818 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G818 (CL:COND ((CONS? (CL:CDR X)) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST (CL:FUNCTION EQ)))))))))))
  (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)))))
  (CL:DEFUN %NONDECIMAL-DIGIT? (X START BASE) (CL:BLOCK %NONDECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X START (CODE-CHAR (+ (CL:CHAR-CODE START) (- BASE 10)))))))
  (CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:LABELS ((~G820 (~G217) (CL:COND ((CONS? ~G217) (%PRINT-CONS X STR INFO)) ((SYMBOL? ~G217) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G217) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G217) (PRINC X STR)) ((STRING? ~G217) (%PRINT-STRING X STR)) ((ARRAY? ~G217) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G217) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G217) (%PRINT-OBJECT X STR INFO)) (T (%ERROR "Don't know how to print object."))))) (~G820 X))))))
  (CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (CL:LABELS ((~G821 (~G191) (CL:PROGN (=-PRINT-INFO-INDENTATION (%BODY-INDENTATION INFO) INFO)) (CL:LABELS ((~G822 (~G192) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G191 INFO)) ~G192)) (~G822 (CL:PROGN (CL:LABELS ((~G823 (FIRST?) (CL:BLOCK NIL (CL:LABELS ((~G824 (~G195) (CL:LABELS ((~G825 (I) (CL:TAGBODY ~G193 (CL:COND ((NOT ~G195) (CL:GO ~G194))) (CL:SETQ I (CL:CAR ~G195)) (CL:COND (FIRST? (CL:PROGN (CL:SETQ FIRST? NIL))) (T (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))))) (%LATE-PRINT I STR INFO) (CL:SETQ ~G195 (CL:CDR ~G195)) (CL:GO ~G193) ~G194 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G825 NIL)))) (~G824 X))))) (~G823 T))))))) (~G821 (PRINT-INFO-INDENTATION INFO))))))
  (CL:DEFUN =-PRINT-INFO-COLUMNS (VAL ARR) (CL:BLOCK =-PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN PRINT-INFO-COLUMNS (ARR) (CL:BLOCK PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN %PRINT-INDENTATION (STR INFO) (CL:BLOCK %PRINT-INDENTATION (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((FRESH-LINE? STR) (CL:LABELS ((~G826 (~G188) (CL:BLOCK NIL (CL:LABELS ((~G827 (!) (CL:TAGBODY ~G189 (CL:COND ((== ! ~G188) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G189)))) (~G827 0))))) (~G826 (INTEGER (PRINT-INFO-INDENTATION INFO)))))))))))
  (CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION) (COLUMNS 'COLUMNS)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G828 (~G186) (CL:PROGN (=-AREF 'STRUCT ~G186 0) (=-AREF 'PRINT-INFO ~G186 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) NIL) (T PRETTY-PRINT?)) ~G186 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G186 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G186 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMNS 'COLUMNS) NIL) (T COLUMNS)) ~G186 5)) ~G186)) (~G828 (MAKE-ARRAY 6))))))
  (CL:DEFUN CHARRANGE? (X START END) (CL:BLOCK CHARRANGE? (CL:BLOCK NIL (RANGE? (CL:CHAR-CODE X) (CL:CHAR-CODE START) (CL:CHAR-CODE END)))))
  (CL:DEFUN LOWER-CASE? (CL:&REST ~G58) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G829 (~G62) (CL:LABELS ((~G830 (C) (CL:TAGBODY ~G60 (CL:COND ((NOT ~G62) (CL:GO ~G61))) (CL:SETQ C (CL:CAR ~G62)) (CL:LABELS ((~G831 (~G59) (CL:COND (~G59 ~G59) (T (CL:RETURN-FROM NIL NIL))))) (~G831 (CHARRANGE? C #\a #\z))) (CL:SETQ ~G62 (CL:CDR ~G62)) (CL:GO ~G60) ~G61 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G830 NIL)))) (~G829 ~G58))))))
  (CL:DEFUN FORMAT-INFO-TEXT (ARR) (CL:BLOCK FORMAT-INFO-TEXT (CL:BLOCK NIL (CL:AREF ARR 3))))
  (CL:DEFUN LATE-PRINT (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*) CL:&KEY (PRINT-INFO (MAKE-PRINT-INFO))) (CL:BLOCK LATE-PRINT (CL:BLOCK NIL (CL:LABELS ((~G832 (~G218) (CL:LABELS ((~G833 (S) (CL:LABELS ((~G834 (~G219) (CL:COND (~G218 ~G219) (T (GET-STREAM-STRING S))))) (~G834 (CL:PROGN (CL:COND ((CL:COND ((CONS? X) (CONS? (CL:CAR X)))) (CL:PROGN (%PRINT-INDENTATION S PRINT-INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) (PRINC "(" S) (%PRINT-BODY X S PRINT-INFO) (PRINC ")" S) (CL:LABELS ((~G835 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) RET)) (~G835 (CL:CAR (PRINT-INFO-COLUMNS PRINT-INFO)))))) (T (%LATE-PRINT X S PRINT-INFO))) (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (CL:COND ((NOT (FRESH-LINE? S)) (TERPRI S)))))))))) (~G833 (DEFAULT-STREAM ~G218))))) (~G832 STR)) X)))
  (CL:DEFUN NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (INTEGER (++ (* SIZE (++ (/ (-- COLUMN) SIZE))))))))
  (CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  (CL:DEFUN =-STREAM-LOCATION-COLUMN (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
  (CL:DEFUN STREAM-LOCATION-TABSIZE (ARR) (CL:BLOCK STREAM-LOCATION-TABSIZE (CL:BLOCK NIL (CL:AREF ARR 6))))
  (CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G836 (~G74) (CL:COND (~G74 ~G74) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G836 (%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 ((~G837 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (GENERIC-SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (LIST SEQ))))) (~G837 (POSITION OBJ SEQ :TEST TEST))))))))
  (CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
  (CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G838 (~G238) (CL:COND (~G238 ~G238) (T (CL:LABELS ((~G839 (~G239) (CL:COND (~G239 ~G239) (T (CL:LABELS ((~G840 (~G240) (CL:COND (~G240 ~G240) (T (CL:LABELS ((~G841 (~G241) (CL:COND (~G241 ~G241) (T (CL:LABELS ((~G842 (~G242) (CL:COND (~G242 ~G242) (T (CL:LABELS ((~G843 (~G243) (CL:COND (~G243 ~G243) (T (CL:LABELS ((~G844 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G845 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G846 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G847 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G848 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G849 (~G249) (CL:COND (~G249 ~G249) (T (CL:LABELS ((~G850 (~G250) (CL:COND (~G250 ~G250) (T (EQL X #\^))))) (~G850 (EQL X #\#))))))) (~G849 (EQL X #\;))))))) (~G848 (EQL X #\:))))))) (~G847 (EQL X #\,))))))) (~G846 (EQL X #\`))))))) (~G845 (EQL X #\'))))))) (~G844 (EQL X #\"))))))) (~G843 (EQL X #\}))))))) (~G842 (EQL X #\{))))))) (~G841 (EQL X #\]))))))) (~G840 (EQL X #\[))))))) (~G839 (EQL X #\)))))))) (~G838 (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 ((~G851 (!) (CL:COND (! (CL:PROGN (CL:COND ((DIGIT-CHAR? !) !))))))) (~G851 (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 ((~G852 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G852 (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 ((~G853 (E) (CL:LABELS ((~G854 (S) (CL:COND ((CL:LABELS ((~G855 (~G95) (CL:COND (~G95 ~G95) (T (CL:COND ((< S E) FROM-END)))))) (~G855 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G856 (~G96) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G96)))) (~G856 S)))) (CL:BLOCK NIL (CL:LABELS ((~G857 (I) (CL:TAGBODY ~G97 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G858 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (LIST I))))) (CL:RETURN-FROM NIL !))))) (~G858 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G97)))) (~G857 S))))) (~G854 (CL:LABELS ((~G859 (~G94) (CL:COND (~G94 ~G94) (T 0)))) (~G859 START)))))) (~G853 (CL:LABELS ((~G860 (~G93) (CL:COND (~G93 ~G93) (T (-- (CL:LENGTH SEQ)))))) (~G860 END)))))))))))
  (CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G861 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G862 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G863 (~G92) (CL:LABELS ((~G864 (I) (CL:TAGBODY ~G90 (CL:COND ((NOT ~G92) (CL:GO ~G91))) (CL:SETQ I (CL:CAR ~G92)) (CL:COND ((FUNCALL PRED I IDX) (CL:RETURN-FROM NIL I))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G92 (CL:CDR ~G92)) (CL:GO ~G90) ~G91 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G864 NIL)))) (~G863 !))))) (~G862 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G865 (~G89) (CL:LABELS ((~G866 (I) (CL:TAGBODY ~G87 (CL:COND ((NOT ~G89) (CL:GO ~G88))) (CL:SETQ I (CL:CAR ~G89)) (CL:COND ((FUNCALL PRED I) (CL:RETURN-FROM NIL I))) (CL:SETQ ~G89 (CL:CDR ~G89)) (CL:GO ~G87) ~G88 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G866 NIL)))) (~G865 !))))))) (~G861 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G867 (!) (CL:BLOCK NIL (CL:LABELS ((~G868 (~G23) (CL:LABELS ((~G869 (I) (CL:TAGBODY ~G21 (CL:COND ((NOT ~G23) (CL:GO ~G22))) (CL:SETQ I (CL:CAR ~G23)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G23 (CL:CDR ~G23)) (CL:GO ~G21) ~G22 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G869 NIL)))) (~G868 LST))))) (~G867 NIL)))))
  (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 (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 QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G870 (~G9) (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))))) ~G9)) (~G870 (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 ((~G871 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (DECIMALS-CHARS !) STR)))))) (~G871 (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 ((~G872 (!) (CL:COND (! (DIGIT-CHAR? !))))) (~G872 (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 ((~G873 (!) (CL:COND (! (CL:PROGN (EQL #\. !)))))) (~G873 (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 ((~G874 (~G76) (CL:COND (~G76 ~G76) (T (CL:LABELS ((~G875 (~G77) (CL:COND (~G77 ~G77) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G875 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G874 (DIGIT-CHAR? X))))))
  (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-MAKE-SYMBOL (SYM CL:&OPTIONAL (PKG NIL)) (CL:BLOCK READ-MAKE-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G876 (!) (CL:COND (! (MAKE-SYMBOL SYM !)) (T (CL:LABELS ((~G877 (~G262) (CL:COND (~G262 ~G262) (T (MAKE-SYMBOL SYM *PACKAGE*))))) (~G877 (FIND-SYMBOL SYM *PACKAGE*))))))) (~G876 PKG)))))
  (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 ((~G878 (~G101) (CL:LABELS ((~G879 (SEQ) (CL:TAGBODY ~G99 (CL:COND ((NOT ~G101) (CL:GO ~G100))) (CL:SETQ SEQ (CL:CAR ~G101)) (CL:LABELS ((~G880 (~G102) (CL:BLOCK NIL (CL:LABELS ((~G881 (!) (CL:TAGBODY ~G103 (CL:COND ((== ! ~G102) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G882 (~G98) (CL:COND (~G98 ~G98) (T (CL:RETURN-FROM EVERY NIL))))) (~G882 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G103)))) (~G881 0))))) (~G880 (INTEGER (CL:LENGTH SEQ)))) (CL:SETQ ~G101 (CL:CDR ~G101)) (CL:GO ~G99) ~G100 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G879 NIL)))) (~G878 SEQS))))))
  (CL:DEFUN DIGIT-CHAR? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT-CHAR? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G883 (~G75) (CL:COND (~G75 ~G75) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G883 (DECIMAL-DIGIT? C))))))))
  (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 ((~G884 (~G145) (CL:LABELS ((~G885 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G886 (~G146) (CL:COND (~G146 (CL:PROGN (CL:LABELS ((~G887 (~G148) (CL:BLOCK NIL (CL:LABELS ((~G888 (~G147) (CL:TAGBODY ~G149 (CL:COND ((== ~G147 ~G148) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G889 (!) (%TRACK-LOCATION STREAM-LOCATION !))) (~G889 (ELT ~G146 ~G147))) (CL:SETQ ~G147 (NUMBER+ 1 ~G147)) (CL:GO ~G149)))) (~G888 0))))) (~G887 (INTEGER (CL:LENGTH ~G146))))))))) (~G886 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)) (~G885 ~G145 (STREAM-LOCATION-TRACK? ~G145) (STREAM-LOCATION-ID ~G145) (STREAM-LOCATION-LINE ~G145) (STREAM-LOCATION-COLUMN ~G145) (STREAM-LOCATION-TABSIZE ~G145))))) (~G884 STREAM-LOCATION)))))
  (CL:DEFUN %FORMAT-DIRECTIVE-TILDE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-TILDE (CL:BLOCK NIL (PRINC #\~ (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
  (CL:DEFUN %FORMAT-DIRECTIVE-FRESH-LINE (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-FRESH-LINE (CL:BLOCK NIL (FRESH-LINE (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
  (CL:DEFUN %FORMAT-DIRECTIVE-FORCE-OUTPUT (INF TXT ARGS) (CL:BLOCK %FORMAT-DIRECTIVE-FORCE-OUTPUT (CL:BLOCK NIL (FORCE-OUTPUT (FORMAT-INFO-STREAM INF)) (%FORMAT INF TXT ARGS))))
  