anchor.diff:  (CL:PROGN (CL:DEFUN NUMBER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'NUMBER> *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER>)))
   (CL:PROGN (CL:DEFUN INTEGER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'INTEGER> *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER>)))
   (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
  -(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1153 (TESTS) (CL:LABELS ((~G1154 (END) (CL:COND ((NOT BODY) (CL:PROGN (ERROR "Body is missing.")))) (CL:CONS 'CL:COND (APPEND (CL:COND ((SOLE? END) (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END)))) (T TESTS)) NIL)))) (~G1154 (CL:CAR (CL:LAST TESTS)))))) (~G1153 (GROUP BODY 2))))))
  +(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1152 (TESTS) (CL:LABELS ((~G1153 (END) (CL:COND ((NOT BODY) (CL:PROGN (ERROR "Body is missing.")))) (CL:CONS 'CL:COND (APPEND (CL:COND ((SOLE? END) (+ (BUTLAST TESTS) (CL:LIST (CL:CONS T END)))) (T TESTS)) NIL)))) (~G1153 (CL:CAR (CL:LAST TESTS)))))) (~G1152 (GROUP BODY 2))))))
   (CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
  -(CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1155 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1155 (CL:APPLY *MACROCALL* (CL:LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
  +(CL:DEFUN %MACROEXPAND (X) (CL:COND ((CL:ATOM X) X) ((CL:APPLY *MACRO?* (CL:LIST X)) (CL:LABELS ((~G1154 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1154 (CL:APPLY *MACROCALL* (CL:LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (CL:LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
   (CL:DEFUN FUNCALL (FUN CL:&REST ARGS) (CL:BLOCK FUNCALL (CL:BLOCK NIL (CL:APPLY FUN ARGS))))
   (CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
  -(CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1156 (~G131) (CL:LABELS ((~G1157 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1157 NIL)))) (~G1156 LST))))))))
  +(CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1155 (~G131) (CL:LABELS ((~G1156 (I) (CL:TAGBODY ~G129 (CL:COND ((NOT ~G131) (CL:GO ~G130))) (CL:SETQ I (CL:CAR ~G131)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G131 (CL:CDR ~G131)) (CL:GO ~G129) ~G130 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1156 NIL)))) (~G1155 LST))))))))
   (CL:DEFUN TRE-SYMBOL (X) (CL:BLOCK TRE-SYMBOL (CL:BLOCK NIL (CL:INTERN (SYMBOL-NAME X) "TRE"))))
   (CL:DEFUN CLOSE (STR) (CL:BLOCK CLOSE (CL:BLOCK NIL (%FCLOSE (STREAM-HANDLE STR)))))
  -(CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1158 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1158 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  +(CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1157 (!) (CL:COND (! (MAKE-STREAM-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1157 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
  +(CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  +(CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1158 (~G125) (CL:LABELS ((~G1159 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1159 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1158 X)) (CL:LABELS ((~G1160 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1160 *DEFAULT-LISTPROP*)))) (T X)))))
  +(CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (CL:COND ((SEEK-CHAR STR) (READ-EXPR STR))))))
  +(CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1161 (~G236) (CL:COND (~G236 ~G236) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1161 (STREAM-PEEKED-CHAR STR))))))
  +(CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  +(CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1162 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1163 (~G335) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G334)) ~G335)) (~G1163 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1162 *PRINT-AUTOMATIC-NEWLINE?*)))))
  +(CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1164 (~G734) (CL:COND ((CL:ATOM ~G734) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G734) (QQ _)) ((QUASIQUOTE-SPLICE? ~G734) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1164 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1165 (~G735) (CL:COND ((QUOTE? ~G735) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G735) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1165 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING (CL:FUNCTION DISP)))))))
  +(CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((== _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  +(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1166 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1166 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  +(CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  +(CL:DEFUN GENSYM NIL (CL:LABELS ((~G1167 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1167 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  +(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1168 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1168 (CL:CAR X))))
   (CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (CL:LIST X)))))
  -(CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (CL:LIST X))))
  -(CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:PROGN (CL:LABELS ((~G1159 (~G125) (CL:LABELS ((~G1160 (!) (CL:COND (! (CL:PROGN (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* !))))))) (~G1160 (CL:COND ((CONS? ~G125) (CPR ~G125))))))) (~G1159 X)) (CL:LABELS ((~G1161 (~G124) (RPLACP (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X))) ~G124))) (~G1161 *DEFAULT-LISTPROP*)))) (T X)))))
  -(CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (SKIP-SPACES STR) (CL:COND ((PEEK-CHAR STR) (READ-EXPR STR))))))
  -(CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1162 (~G233) (CL:COND (~G233 ~G233) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1162 (STREAM-PEEKED-CHAR STR))))))
  -(CL:DEFUN CADR (LST) (CL:CAR (CL:CDR LST)))
  -(CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1163 (~G333) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1164 (~G334) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G333)) ~G334)) (~G1164 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1163 *PRINT-AUTOMATIC-NEWLINE?*)))))
  -(CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:CONS 'APPEND (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((CL:ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1165 (~G733) (CL:COND ((CL:ATOM ~G733) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G733) (QQ _)) ((QUASIQUOTE-SPLICE? ~G733) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1165 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1166 (~G734) (CL:COND ((QUOTE? ~G734) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G734) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1166 _))))) (CL:CAR (TREE-WALK (CL:LIST X) :ASCENDING (CL:FUNCTION DISP)))))))
  -(CL:DEFUN NEUTRALIZE-FORMAT-STRING (X) (CL:BLOCK NEUTRALIZE-FORMAT-STRING (CL:BLOCK NIL (LIST-STRING (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((== _ #\~) (CL:LIST _ _)) (T (CL:LIST _))))) (STRING-LIST X))))))
  -(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1167 (~G6) (CL:COND (~G6 ~G6) (T (CL:ATOM Y))))) (~G1167 (CL:ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
  -(CL:DEFUN CADAR (LST) (CADR (CL:CAR LST)))
  -(CL:DEFUN GENSYM NIL (CL:LABELS ((~G1168 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1168 (MAKE-SYMBOL (STRING-CONCAT *GENSYM-PREFIX* (STRING (GENSYM-NUMBER)))))))
  -(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1169 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1169 (CL:CAR X))))
   (CL:DEFUN IDENTITY (X) X)
  +(CL:DEFVAR *DEFINITION-PRINTER*)
   (CL:DEFVAR *GENSYM-PREFIX*)
   (CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
   (CL:DEFVAR *STANDARD-INPUT*)
  -(CL:DEFVAR *DEFINITION-PRINTER*)
   (CL:DEFVAR *MACROEXPAND-BACKQUOTE*)
   (CL:DEFVAR *MACROCALL*)
   (CL:DEFVAR *MACRO?*)
  
positive.code: (CL:DEFVAR *GENSYM-COUNTER*)
  (CL:DEFUN COPY-HEAD (X SIZE) (CL:BLOCK COPY-HEAD (CL:BLOCK NIL (CL:COND ((CL:COND (X (< 0 SIZE))) (CL:CONS (CL:CAR X) (COPY-HEAD (CL:CDR X) (-- SIZE))))))))
  (CL:DEFUN CARLIST (~G126) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G126))))
  (CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF ALST APPLY-VALUES? CONCATENATE-SUBLISTS? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1206 (~G189) (CL:LABELS ((~G1207 (~G190) (CL:COND ((NOT (EQ (CL:CAR ~G189) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G189)))) (CL:LABELS ((~G1208 (A) (CL:LABELS ((~G1209 (~G191) (CL:LABELS ((~G1210 (K) (CL:LABELS ((~G1211 (ARGDEFS) (CL:LABELS ((~G1212 (KEY-ARGS) (CL:LABELS ((~G1213 (NUM) (CL:LABELS ((~G1214 (NO-STATIC) (CL:LABELS ((~G1215 (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 ((~G1216 (K) (CL:COND (K (CL:LABELS ((~G1217 (!) (CL:RPLACD K (CL:CAR (CL:CDR !))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1217 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1216 (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 ((~G1218 (~G187) (CL:COND ((EQ ~G187 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G187 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G187 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1218 (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 ((~G1219 (~G188) (CL:COND (~G188 ~G188) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1219 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1220 (!) (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)))))) (~G1220 (EXP-MAIN ARGDEFS ALST)))))) (~G1215 NIL)))) (~G1214 NIL)))) (~G1213 0)))) (~G1212 K)))) (~G1211 A)))) (~G1210 (CL:CAR ~G191))))) (~G1209 (CL:LABELS ((~G1221 (~G193) (CL:COND (~G193 ~G193) (T (%ERROR "Not enough VALUES."))))) (~G1221 (CL:CDR ~G190))))))) (~G1208 (CL:CAR ~G190))))) (~G1207 (CL:CDR ~G189))))) (~G1206 (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 ((~G1222 (~G181) (CL:COND (~G181 ~G181) (T (%BODY? X))))) (~G1222 (%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 ((~G1223 (~G64) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G64)))) (~G1223 START)))) (CL:LABELS ((~G1224 (~G65) (CL:COND ((CONS? ~G65) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G65) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G65) (%SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1224 SEQ))))))))
  (CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1225 (~G112) (CL:LABELS ((~G1226 (~G113) (CL:COND ((NOT (EQ (CL:CAR ~G112) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G112)))) (CL:LABELS ((~G1227 (NUM-CDRS) (CL:LABELS ((~G1228 (~G114) (CL:LABELS ((~G1229 (WITHOUT-START) (CL:LABELS ((~G1230 (~G117) (CL:LABELS ((~G1231 (~G118) (CL:COND ((NOT (EQ (CL:CAR ~G117) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G117)))) (CL:LABELS ((~G1232 (NUM-CARS) (CL:LABELS ((~G1233 (~G119) (CL:LABELS ((~G1234 (WITHOUT-END) (DOT-EXPAND-MAKE-EXPR 'CL:CAR NUM-CARS (DOT-EXPAND-MAKE-EXPR 'CL:CDR NUM-CDRS (DOT-EXPAND (LIST-SYMBOL WITHOUT-END)))))) (~G1234 (CL:CAR ~G119))))) (~G1233 (CL:LABELS ((~G1235 (~G121) (CL:COND (~G121 ~G121) (T (%ERROR "Not enough VALUES."))))) (~G1235 (CL:CDR ~G118))))))) (~G1232 (CL:CAR ~G118))))) (~G1231 (CL:CDR ~G117))))) (~G1230 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1229 (CL:CAR ~G114))))) (~G1228 (CL:LABELS ((~G1236 (~G116) (CL:COND (~G116 ~G116) (T (%ERROR "Not enough VALUES."))))) (~G1236 (CL:CDR ~G113))))))) (~G1227 (CL:CAR ~G113))))) (~G1226 (CL:CDR ~G112))))) (~G1225 (DOT-EXPAND-HEAD-LENGTH X))))))
  (CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1237 (SL) (CL:LABELS ((~G1238 (~G123) (CL:COND (~G123 ~G123) (T (== #\. (CL:CAR (CL:LAST SL))))))) (~G1238 (== #\. (CL:CAR SL)))))) (~G1237 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1239 (SL) (CL:LABELS ((~G1240 (L) (CL:LABELS ((~G1241 (P) (CL:LABELS ((~G1242 (~G122) (CL:COND (~G122 ~G122) (T (NOT P))))) (~G1242 (== 1 L))))) (~G1241 (DOT-POSITION SL))))) (~G1240 (CL:LENGTH SL))))) (~G1239 (STRING-LIST (SYMBOL-NAME X)))))))
  (CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X :TEST (CL:FUNCTION ==)))))
  (CL:DEFUN READ-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-CHAR (CL:BLOCK NIL (%TRACK-LOCATION (STREAM-INPUT-LOCATION STR) (READ-CHAR-0 STR)))))
  (CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((< X 33) (>= X 0))))))
  (CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1243 (C) (CL:COND (C (CL:PROGN (CL:COND ((== C 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1243 (READ-CHAR STR))))))
  (CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1244 (~G275) (CL:COND ((EQ ~G275 'DBLQUOTE) (READ-STRING STR)) ((EQ ~G275 'CHAR) (READ-CHAR STR)) ((EQ ~G275 'NUMBER) (CL:LABELS ((~G1245 (S) (PRINC (LIST-STRING SYM) S) (CL:PROGN (READ-NUMBER S)))) (~G1245 (MAKE-STRING-STREAM)))) ((EQ ~G275 'HEXNUM) (READ-HEX STR)) ((EQ ~G275 'CL:FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G275 'SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE SYM PKG)) (T (CL:COND ((%READ-CLOSING-BRACKET? TOKEN) (ERROR "~A bracket missing." (CL:LABELS ((~G1246 (~G276) (CL:COND ((EQUAL ~G276 'BRACKET-CLOSE) "Round") ((EQUAL ~G276 'CURLY-BRACKET-CLOSE) "Curly") ((EQUAL ~G276 'SQUARE-BRACKET-CLOSE) "Square")))) (~G1246 TOKEN)))) (T (ERROR "Syntax error: token ~A, sym ~A." TOKEN SYM))))))) (~G1244 TOKEN)))))
  (CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (CL:LIST TOKEN (READ-EXPR STR)))))
  (CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1247 (~G244) (CL:COND (~G244 ~G244) (T (CL:LABELS ((~G1248 (~G245) (CL:COND (~G245 ~G245) (T (CL:LABELS ((~G1249 (~G246) (CL:COND (~G246 ~G246) (T (CL:LABELS ((~G1250 (~G247) (CL:COND (~G247 ~G247) (T (EQ X 'ACCENT-CIRCONFLEX))))) (~G1250 (EQ X 'QUASIQUOTE-SPLICE))))))) (~G1249 (EQ X 'QUASIQUOTE))))))) (~G1248 (EQ X 'BACKQUOTE))))))) (~G1247 (EQ X 'CL:QUOTE))))))
  (CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (READ-SET-LISTPROP STR) (CL:LABELS ((~G1251 (~G304) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1252 (~G305) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G304)) ~G305)) (~G1252 (CL:PROGN (CL:LABELS ((~G1253 (!) (CL:COND ((== #\. (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1254 (~G306) (CL:LABELS ((~G1255 (~G307) (CL:COND ((NOT (EQ (CL:CAR ~G306) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G306)))) (CL:LABELS ((~G1256 (TOKEN) (CL:LABELS ((~G1257 (~G308) (CL:LABELS ((~G1258 (PKG) (CL:LABELS ((~G1259 (~G309) (CL:LABELS ((~G1260 (SYM) (READ-SLOT-VALUE (CL:LIST ! (LIST-STRING SYM))))) (~G1260 (CL:CAR ~G309))))) (~G1259 (CL:LABELS ((~G1261 (~G312) (CL:COND (~G312 ~G312) (T (%ERROR "Not enough VALUES."))))) (~G1261 (CL:CDR ~G308))))))) (~G1258 (CL:CAR ~G308))))) (~G1257 (CL:LABELS ((~G1262 (~G311) (CL:COND (~G311 ~G311) (T (%ERROR "Not enough VALUES."))))) (~G1262 (CL:CDR ~G307))))))) (~G1256 (CL:CAR ~G307))))) (~G1255 (CL:CDR ~G306))))) (~G1254 (READ-TOKEN STR))))) (T !)))) (~G1253 (READ-CONS STR)))))))) (~G1251 *DEFAULT-LISTPROP*)))))
  (CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1263 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1264 (~G270) (CL:LABELS ((~G1265 (~G271) (CL:COND ((NOT (EQ (CL:CAR ~G270) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G270)))) (CL:LABELS ((~G1266 (PKG) (CL:LABELS ((~G1267 (~G272) (CL:LABELS ((~G1268 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (== #\. (CL:CAR SYM)))))) 'DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) 'NUMBER) (T 'SYMBOL))) (T (CL:LABELS ((~G1269 (~G268) (CL:COND ((CHARACTER== ~G268 #\() 'BRACKET-OPEN) ((CHARACTER== ~G268 #\)) 'BRACKET-CLOSE) ((CHARACTER== ~G268 #\[) 'SQUARE-BRACKET-OPEN) ((CHARACTER== ~G268 #\]) 'SQUARE-BRACKET-CLOSE) ((CHARACTER== ~G268 #\{) 'CURLY-BRACKET-OPEN) ((CHARACTER== ~G268 #\}) 'CURLY-BRACKET-CLOSE) ((CHARACTER== ~G268 #\') 'CL:QUOTE) ((CHARACTER== ~G268 #\`) 'BACKQUOTE) ((CHARACTER== ~G268 #\^) 'ACCENT-CIRCONFLEX) ((CHARACTER== ~G268 #\") 'DBLQUOTE) ((CHARACTER== ~G268 #\,) (CL:COND ((== #\@ (PEEK-CHAR STR)) (CL:COND ((READ-CHAR STR) 'QUASIQUOTE-SPLICE))) (T 'QUASIQUOTE))) ((CHARACTER== ~G268 #\#) (CL:LABELS ((~G1270 (~G269) (CL:COND ((CHARACTER== ~G269 #\\) 'CHAR) ((CHARACTER== ~G269 #\x) 'HEXNUM) ((CHARACTER== ~G269 #\') 'CL:FUNCTION) ((CHARACTER== ~G269 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Invalid character after '#'."))))) (~G1270 (READ-CHAR STR)))) ((CHARACTER== ~G268 -1) 'EOF)))) (~G1269 (READ-CHAR STR))))))) PKG SYM))) (~G1268 (CL:CAR ~G272))))) (~G1267 (CL:LABELS ((~G1271 (~G274) (CL:COND (~G274 ~G274) (T (%ERROR "Not enough VALUES."))))) (~G1271 (CL:CDR ~G271))))))) (~G1266 (CL:CAR ~G271))))) (~G1265 (CL:CDR ~G270))))) (~G1264 !))))))) (~G1263 (GET-SYMBOL-AND-PACKAGE STR))))))
  (CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
  (CL:DEFUN STREAM-FUN-IN (ARR) (CL:BLOCK STREAM-FUN-IN (CL:BLOCK NIL (CL:AREF ARR 3))))
  (CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1272 (!) (CL:COND (! (CL:PROGN (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) !))))) (~G1272 (STREAM-PEEKED-CHAR STR))))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1273 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1273 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1274 (~G177) (CL:LABELS ((~G1275 (S) (CL:LABELS ((~G1276 (~G178) (CL:COND (~G177 ~G178) (T (GET-STREAM-STRING S))))) (~G1276 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1275 (DEFAULT-STREAM ~G177))))) (~G1274 STR)))))
  (CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1277 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1277 (STREAM-OUTPUT-LOCATION STR))))))
  (CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1278 (~G165) (CL:COND ((EQ ~G165 NIL) (MAKE-STRING-STREAM)) ((EQ ~G165 T) *STANDARD-OUTPUT*) (T X)))) (~G1278 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 ((~G1279 (~G157) (CL:PROGN (=-AREF 'STRUCT ~G157 0) (=-AREF 'STREAM ~G157 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G157 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G157 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G157 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G157 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G157 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G157 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G157 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T OUTPUT-LOCATION)) ~G157 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G157 10)) ~G157)) (~G1279 (MAKE-ARRAY 11))))))
  (CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
  (CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
  (CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
  (CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G1280 (~G164) (CL:LABELS ((~G1281 (!) (CL:TAGBODY ~G162 (CL:COND ((NOT ~G164) (CL:GO ~G163))) (CL:SETQ ! (CL:CAR ~G164)) (STREAM-PRINC ! STR) (CL:SETQ ~G164 (CL:CDR ~G164)) (CL:GO ~G162) ~G163 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1281 NIL)))) (~G1280 X)))) ((CL:LABELS ((~G1282 (~G161) (CL:COND (~G161 ~G161) (T (CHARACTER? X))))) (~G1282 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (ZERO? (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (ELT X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (ERROR "Can only print strings and characters. Got ~A." X))))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION STRING-CONCAT) (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((STRING? _) _) ((CHARACTER? _) (STRING _))))) (QUEUE-LIST X))))))
  (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
  (CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS 'VALUES VALS))))
  (CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G264 (CL:COND ((NOT (NOT (CL:COND ((== #\| (READ-CHAR STR)) (== #\# (PEEK-CHAR STR)))))) (CL:RETURN-FROM NIL (CL:PROGN (READ-CHAR STR))))) NIL (CL:GO ~G264)))))))
  (CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1283 (~G265) (CL:COND (~G265 ~G265) (T (DIGIT-CHAR? (CL:CAR X)))))) (~G1283 (CL:COND ((CL:CDR X) (CL:LABELS ((~G1284 (~G266) (CL:COND (~G266 ~G266) (T (== #\. (CL:CAR X)))))) (~G1284 (== #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G1285 (~G267) (CL:COND (~G267 ~G267) (T (== #\. _))))) (~G1285 (DIGIT-CHAR? _))))) (CL:CDR X))) (T T)))))))
  (CL:DEFUN GET-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK GET-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (SKIP-SPACES STR) (CL:LABELS ((~G1286 (SYM) (CL:LABELS ((~G1287 (!) (CL:COND (! (CL:PROGN (CL:COND ((== ! #\:) (VALUES (CL:LABELS ((~G1288 (~G263) (CL:COND (~G263 ~G263) (T T)))) (~G1288 SYM)) (CL:COND ((READ-CHAR STR) (GET-SYMBOL STR))))) (T (VALUES NIL SYM)))))))) (~G1287 (PEEK-CHAR STR))))) (~G1286 (GET-SYMBOL STR))))))
  (CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND (X (CL:COND ((CL:CDR X) (CL:CONS 'SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (MAKE-SYMBOL (CL:CAR (CL:LAST X))) NIL)) NIL)))) (T (CL:COND ((STRING? (CL:CAR X)) (MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))))))
  (CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((~G1289 (LOC) (CL:LABELS ((~G1290 (LINE) (CL:LABELS ((~G1291 (COLUMN) (CL:LABELS ((~G1292 (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 ((~G1293 (~G277) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1294 (~G278) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G277)) ~G278)) (~G1294 (CL:PROGN (CL:LABELS ((~G1295 (~G279) (CL:COND ((EQ ~G279 'BRACKET-OPEN) (READ-CONS-SLOT STR)) ((EQ ~G279 'SQUARE-BRACKET-OPEN) (CL:CONS 'SQUARE (READ-CONS-SLOT STR))) ((EQ ~G279 '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))))))) (~G1295 TOKEN))))))) (~G1293 *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1296 (~G280) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* *DEFAULT-LISTPROP*)) (CL:LABELS ((~G1297 (~G281) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* ~G280)) ~G281)) (~G1297 (CL:PROGN (CL:LABELS ((~G1298 (!) (CL:COND (! (CL:LABELS ((~G1299 (~G283) (CL:LABELS ((~G1300 (~G284) (CL:COND ((NOT (EQ (CL:CAR ~G283) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G283)))) (CL:LABELS ((~G1301 (TOKEN) (CL:LABELS ((~G1302 (~G285) (CL:LABELS ((~G1303 (PKG) (CL:LABELS ((~G1304 (~G286) (CL:LABELS ((~G1305 (SYM) (CL:COND ((EQ 'DOT TOKEN) (CL:LABELS ((~G1306 (X) (CL:LABELS ((~G1307 (~G290) (CL:LABELS ((~G1308 (~G291) (CL:COND ((NOT (EQ (CL:CAR ~G290) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G290)))) (CL:LABELS ((~G1309 (TOKEN) (CL:LABELS ((~G1310 (~G292) (CL:LABELS ((~G1311 (PKG) (CL:LABELS ((~G1312 (~G293) (CL:LABELS ((~G1313 (SYM) (CL:LABELS ((~G1314 (~G282) (CL:COND (~G282 ~G282) (T (ERR "Only one value allowed after dotted cons."))))) (~G1314 (%READ-CLOSING-BRACKET? TOKEN))) X)) (~G1313 (CL:CAR ~G293))))) (~G1312 (CL:LABELS ((~G1315 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1315 (CL:CDR ~G292))))))) (~G1311 (CL:CAR ~G292))))) (~G1310 (CL:LABELS ((~G1316 (~G295) (CL:COND (~G295 ~G295) (T (%ERROR "Not enough VALUES."))))) (~G1316 (CL:CDR ~G291))))))) (~G1309 (CL:CAR ~G291))))) (~G1308 (CL:CDR ~G290))))) (~G1307 (READ-TOKEN STR))))) (~G1306 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1305 (CL:CAR ~G286))))) (~G1304 (CL:LABELS ((~G1317 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1317 (CL:CDR ~G285))))))) (~G1303 (CL:CAR ~G285))))) (~G1302 (CL:LABELS ((~G1318 (~G288) (CL:COND (~G288 ~G288) (T (%ERROR "Not enough VALUES."))))) (~G1318 (CL:CDR ~G284))))))) (~G1301 (CL:CAR ~G284))))) (~G1300 (CL:CDR ~G283))))) (~G1299 !))) (T (ERR "Closing bracket missing."))))) (~G1298 (READ-TOKEN STR)))))))) (~G1296 *DEFAULT-LISTPROP*)))))))) (CL:LABELS ((~G1319 (~G297) (CL:LABELS ((~G1320 (~G298) (CL:COND ((NOT (EQ (CL:CAR ~G297) 'VALUES)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G297)))) (CL:LABELS ((~G1321 (TOKEN) (CL:LABELS ((~G1322 (~G299) (CL:LABELS ((~G1323 (PKG) (CL:LABELS ((~G1324 (~G300) (CL:LABELS ((~G1325 (SYM) (CL:COND ((EQ TOKEN 'DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1325 (CL:CAR ~G300))))) (~G1324 (CL:LABELS ((~G1326 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1326 (CL:CDR ~G299))))))) (~G1323 (CL:CAR ~G299))))) (~G1322 (CL:LABELS ((~G1327 (~G302) (CL:COND (~G302 ~G302) (T (%ERROR "Not enough VALUES."))))) (~G1327 (CL:CDR ~G298))))))) (~G1321 (CL:CAR ~G298))))) (~G1320 (CL:CDR ~G297))))) (~G1319 (READ-TOKEN STR)))))) (~G1292 (STREAM-LOCATION-ID LOC))))) (~G1291 (STREAM-LOCATION-COLUMN LOC))))) (~G1290 (STREAM-LOCATION-LINE LOC))))) (~G1289 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN READ-SET-LISTPROP (STR) (CL:BLOCK READ-SET-LISTPROP (CL:BLOCK NIL (CL:LABELS ((~G1328 (!) (CL:PROGN (CL:SETQ *DEFAULT-LISTPROP* (CL:CONS (STREAM-LOCATION-ID !) (CL:CONS (MEMORIZED-NUMBER (STREAM-LOCATION-COLUMN !)) (MEMORIZED-NUMBER (STREAM-LOCATION-LINE !)))))))) (~G1328 (STREAM-INPUT-LOCATION STR))))))
  (CL:DEFUN %READ-CLOSING-BRACKET? (X) (CL:BLOCK %READ-CLOSING-BRACKET? (CL:BLOCK NIL (CL:LABELS ((~G1329 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G1330 (~G249) (CL:COND (~G249 ~G249) (T (EQ X 'CURLY-BRACKET-CLOSE))))) (~G1330 (EQ X 'SQUARE-BRACKET-CLOSE))))))) (~G1329 (EQ X 'BRACKET-CLOSE))))))
  (CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (SYM PKG) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1331 (!) (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) ((EQ T PKG) *KEYWORD-PACKAGE*) (T (LIST-STRING PKG)))))))) (~G1331 (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 ((~G1332 (!) (CL:COND ((HEX-DIGIT-CHAR? !) (CL:PROGN (READ-CHAR STR) (REC (+ (* V 16) (- ! (CL:COND ((DIGIT-CHAR? !) #\0) (T (- #\A 10)))))))) (T V)))) (~G1332 (CHAR-UPCASE (PEEK-CHAR STR)))))) (CL:LABELS ((~G1333 (~G234) (CL:COND (~G234 ~G234) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1333 (HEX-DIGIT-CHAR? (PEEK-CHAR STR)))) (CL:LABELS ((~G1334 (~G235) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G235)) (~G1334 (REC 0)))))))
  (CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((== #\- (PEEK-CHAR STR)) (CL:PROGN (READ-CHAR STR) -1)) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1335 (~G236) (CL:COND (~G236 ~G236) (T 0)))) (~G1335 (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 ((~G1336 (~G175) (CL:LABELS ((~G1337 (S) (CL:LABELS ((~G1338 (~G176) (CL:COND (~G175 ~G176) (T (GET-STREAM-STRING S))))) (~G1338 (CL:PROGN (CL:COND ((STRING? X) (STREAM-PRINC X S)) ((CHARACTER? X) (STREAM-PRINC X S)) ((NUMBER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S))) X))))) (~G1337 (DEFAULT-STREAM ~G175))))) (~G1336 STR)))))
  (CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (STR) (CL:LABELS ((~G1339 (!) (CL:COND ((STRING? (CL:CAR !)) (CL:PROGN (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) (ENQUEUE-LIST (STREAM-USER-DETAIL STR) (APPEND (STRING-LIST (CL:CAR !)) (CL:CDR !)))))))) (~G1339 (QUEUE-LIST (STREAM-USER-DETAIL STR)))) (QUEUE-POP (STREAM-USER-DETAIL STR))) :FUN-OUT (CL:LAMBDA (X STR) (ENQUEUE (STREAM-USER-DETAIL STR) X)) :FUN-EOF (CL:LAMBDA (STR) (NOT (QUEUE-LIST (STREAM-USER-DETAIL STR))))))))
  (CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (LIST-STRING (READ-STRING-0 STR)))))
  (CL:DEFUN >= (N CL:&REST X) (CL:BLOCK >= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1340 (~G13) (CL:LABELS ((~G1341 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT ~G13) (CL:GO ~G12))) (CL:SETQ I (CL:CAR ~G13)) (CL:LABELS ((~G1342 (~G9) (CL:COND (~G9 ~G9) (T (CL:LABELS ((~G1343 (~G10) (CL:COND (~G10 ~G10) (T (CL:RETURN-FROM NIL NIL))))) (~G1343 (> N I))))))) (~G1342 (== N I))) (CL:SETQ N I) (CL:SETQ ~G13 (CL:CDR ~G13)) (CL:GO ~G11) ~G12 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1341 NIL)))) (~G1340 X))))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1344 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1345 (~G160) (CL:LABELS ((~G1346 (!) (CL:TAGBODY ~G158 (CL:COND ((NOT ~G160) (CL:GO ~G159))) (CL:SETQ ! (CL:CAR ~G160)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G160 (CL:CDR ~G160)) (CL:GO ~G158) ~G159 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1346 NIL)))) (~G1345 (STRING-LIST X))))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 X) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 STREAM-LOCATION)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE STREAM-LOCATION) 1) STREAM-LOCATION)))) (T (CL:COND ((== 9 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) STREAM-LOCATION))) ((< 31 X) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN STREAM-LOCATION) 1) STREAM-LOCATION)))))))))))))) X)) (~G1344 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 STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
  (CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1347 (!) (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) !)) (~G1347 NIL)))))
  (CL:DEFUN DOT-EXPAND-MAKE-EXPR (WHICH NUM X) (CL:BLOCK DOT-EXPAND-MAKE-EXPR (CL:BLOCK NIL (CL:COND ((< 0 NUM) (CL:CONS WHICH (CL:CONS (DOT-EXPAND-MAKE-EXPR WHICH (-- NUM) X) NIL))) (T X)))))
  (CL:DEFUN DOT-EXPAND-TAIL-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-TAIL-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR (CL:LAST X))) (DOT-EXPAND-TAIL-LENGTH (BUTLAST X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN DOT-EXPAND-HEAD-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-HEAD-LENGTH (CL:BLOCK NIL (CL:COND ((== #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
  (CL:DEFUN %SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK %SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1348 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1349 (L) (CL:LABELS ((~G1350 (S) (CL:LABELS ((~G1351 (~G62) (CL:COND ((INTEGER< ~G62 0) (ERROR "Negative number of iterations: ~A." ~G62))) (CL:BLOCK NIL (CL:LABELS ((~G1352 (X) (CL:TAGBODY ~G63 (CL:COND ((INTEGER== X ~G62) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G63)))) (~G1352 0))))) (~G1351 (INTEGER L))))) (~G1350 (FUNCALL MAKER L))))) (~G1349 (- END START)))))))) (~G1348 (CL:LENGTH SEQ)))))))))
  (CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((== START END) "") (T (CL:LABELS ((~G1353 (SEQLEN) (CL:COND ((< START SEQLEN) (CL:PROGN (CL:COND ((>= END SEQLEN) (CL:PROGN (CL:PROGN (CL:SETQ END SEQLEN))))) (CL:LABELS ((~G1354 (L) (CL:LABELS ((~G1355 (S) (CL:LABELS ((~G1356 (~G59) (CL:COND ((INTEGER< ~G59 0) (ERROR "Negative number of iterations: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1357 (X) (CL:TAGBODY ~G60 (CL:COND ((INTEGER== X ~G59) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (+ S (STRING (ELT SEQ (+ START X)))))) (CL:SETQ X (INTEGER+ 1 X)) (CL:GO ~G60)))) (~G1357 0))))) (~G1356 (INTEGER L))))) (~G1355 (CL:MAKE-STRING 0))))) (~G1354 (- END START)))))))) (~G1353 (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 ((~G1358 (~G61) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G61)))) (~G1358 START)))) (CL:LABELS ((COPY-NUM (LST LEN) (CL:COND (LST (CL:COND ((< 0 LEN) (CL:CONS (CL:CAR LST) (COPY-NUM (CL:CDR LST) (-- LEN))))))))) (COPY-NUM (CL:NTHCDR START SEQ) (- END START)))))))))
  (CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
  (CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
  (CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
  
negative.code: (CL:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY (CL:FUNCTION %>) X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) (CL:FUNCTION >)))
  (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 ((~G1134 (!) (CL:LABELS ((~G1135 (L) (CL:LABELS ((~G1136 (~G1075) (CL:COND ((INTEGER< ~G1075 0) (ERROR "Negative number of iterations: ~A." ~G1075))) (CL:BLOCK NIL (CL:LABELS ((~G1137 (I) (CL:TAGBODY ~G1076 (CL:COND ((INTEGER== I ~G1075) (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 (INTEGER+ 1 I)) (CL:GO ~G1076)))) (~G1137 0))))) (~G1136 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1135 NIL)))) (~G1134 (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 ((~G1138 (!) (CL:LABELS ((~G1139 (~G1077) (CL:COND ((INTEGER< ~G1077 0) (ERROR "Negative number of iterations: ~A." ~G1077))) (CL:BLOCK NIL (CL:LABELS ((~G1140 (N) (CL:TAGBODY ~G1078 (CL:COND ((INTEGER== N ~G1077) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1078)))) (~G1140 0))))) (~G1139 (INTEGER BITS))))) (~G1138 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
  (CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1141 (!) (CL:LABELS ((~G1142 (~G1079) (CL:COND ((INTEGER< ~G1079 0) (ERROR "Negative number of iterations: ~A." ~G1079))) (CL:BLOCK NIL (CL:LABELS ((~G1143 (N) (CL:TAGBODY ~G1080 (CL:COND ((INTEGER== N ~G1079) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1080)))) (~G1143 0))))) (~G1142 (INTEGER BITS))))) (~G1141 (NUMBER X)))) (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:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1144 (~G1084) (CL:LABELS ((~G1145 (I) (CL:TAGBODY ~G1082 (CL:COND ((NOT ~G1084) (CL:GO ~G1083))) (CL:SETQ I (CL:CAR ~G1084)) (CL:LABELS ((~G1146 (~G1081) (CL:COND (~G1081 ~G1081) (T (CL:RETURN-FROM NIL NIL))))) (~G1146 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1084 (CL:CDR ~G1084)) (CL:GO ~G1082) ~G1083 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1145 NIL)))) (~G1144 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
  (CL:DEFUN TRE-EQL (A B) (CL:COND ((CL:COND ((NUMBER? A) (NUMBER? B))) (CL:COND ((CL:EQ (CL:CHARACTERP A) (CL:CHARACTERP B)) (== A B)))) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((TRE-EQL (CL:CAR A) (CL:CAR B)) (TRE-EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B)) (T (CL:EQ A B))))
  (CL:PROGN (CL:DEFUN EQ (CL:&REST X) (VARIABLE-COMPARE (CL:FUNCTION CL:EQ) X)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
  (CL:PROGN (CL:DEFUN EQL (CL:&REST X) (VARIABLE-COMPARE (CL:FUNCTION TRE-EQL) X)) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
  