anchor.diff:  (CL:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY #'%> X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) #'>))
   (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 ((~G1516 (!) (CL:LABELS ((~G1517 (L) (CL:LABELS ((~G1518 (~G1463) (CL:BLOCK NIL (CL:LABELS ((~G1519 (I) (CL:TAGBODY ~G1464 (CL:COND ((INTEGER== I ~G1463) (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 ~G1464)))) (~G1519 0))))) (~G1518 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1517 NIL)))) (~G1516 (NUMBER X))))
  +(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G1518 (!) (CL:LABELS ((~G1519 (L) (CL:LABELS ((~G1520 (~G1464) (CL:BLOCK NIL (CL:LABELS ((~G1521 (I) (CL:TAGBODY ~G1465 (CL:COND ((INTEGER== I ~G1464) (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 ~G1465)))) (~G1521 0))))) (~G1520 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G1519 NIL)))) (~G1518 (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*) #'BIT-AND))
  -(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1520 (!) (CL:LABELS ((~G1521 (~G1465) (CL:BLOCK NIL (CL:LABELS ((~G1522 (N) (CL:TAGBODY ~G1466 (CL:COND ((INTEGER== N ~G1465) (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 ~G1466)))) (~G1522 0))))) (~G1521 (INTEGER BITS))))) (~G1520 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  -(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1523 (!) (CL:LABELS ((~G1524 (~G1467) (CL:BLOCK NIL (CL:LABELS ((~G1525 (N) (CL:TAGBODY ~G1468 (CL:COND ((INTEGER== N ~G1467) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1468)))) (~G1525 0))))) (~G1524 (INTEGER BITS))))) (~G1523 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) #'<<))
  +(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G1522 (!) (CL:LABELS ((~G1523 (~G1466) (CL:BLOCK NIL (CL:LABELS ((~G1524 (N) (CL:TAGBODY ~G1467 (CL:COND ((INTEGER== N ~G1466) (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 ~G1467)))) (~G1524 0))))) (~G1523 (INTEGER BITS))))) (~G1522 (NUMBER X)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) #'>>))
  +(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G1525 (!) (CL:LABELS ((~G1526 (~G1468) (CL:BLOCK NIL (CL:LABELS ((~G1527 (N) (CL:TAGBODY ~G1469 (CL:COND ((INTEGER== N ~G1468) (CL:RETURN-FROM NIL (CL:PROGN !)))) (CL:PROGN (CL:SETQ ! (* ! 2))) (CL:SETQ N (INTEGER+ 1 N)) (CL:GO ~G1469)))) (~G1527 0))))) (~G1526 (INTEGER BITS))))) (~G1525 (NUMBER X)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) #'<<))
   (CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY #'CL:NOT X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) #'NOT))
  -(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1526 (~G1472) (CL:LABELS ((~G1527 (I) (CL:TAGBODY ~G1470 (CL:COND ((NOT ~G1472) (CL:GO ~G1471))) (CL:SETQ I (CL:CAR ~G1472)) (CL:LABELS ((~G1528 (~G1469) (CL:COND (~G1469 ~G1469) (T (CL:RETURN-FROM NIL NIL))))) (~G1528 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1472 (CL:CDR ~G1472)) (CL:GO ~G1470) ~G1471 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1527 NIL)))) (~G1526 (CL:CDR X))))) (T (CL:ERROR "At least 2 arguments required."))))
  +(CL:DEFUN VARIABLE-COMPARE (PREDICATE X) (CL:COND ((CL:CDR X) (CL:BLOCK NIL (CL:LABELS ((~G1528 (~G1473) (CL:LABELS ((~G1529 (I) (CL:TAGBODY ~G1471 (CL:COND ((NOT ~G1473) (CL:GO ~G1472))) (CL:SETQ I (CL:CAR ~G1473)) (CL:LABELS ((~G1530 (~G1470) (CL:COND (~G1470 ~G1470) (T (CL:RETURN-FROM NIL NIL))))) (~G1530 (FUNCALL PREDICATE (CL:CAR X) I))) (CL:SETQ ~G1473 (CL:CDR ~G1473)) (CL:GO ~G1471) ~G1472 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1529 NIL)))) (~G1528 (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))))) (T (CL:EQ A B))))
   (CL:PROGN (CL:DEFUN EQ (CL:&REST X) (VARIABLE-COMPARE #'CL:EQ X)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) #'EQ))
   (CL:PROGN (CL:DEFUN EQL (CL:&REST X) (VARIABLE-COMPARE #'TRE-EQL X)) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) #'EQL))
  
positive.code: (CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY #'CL:> X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) #'CHARACTER>))
  (CL:PROGN (CL:DEFUN %ERROR (CL:&REST X) (CL:APPLY #'CL:ERROR X)) (CL:SETF (CL:GETHASH '%ERROR *BUILTIN-ATOMS*) #'%ERROR))
  (CL:PROGN (CL:DEFUN %NCONC (CL:&REST X) (CL:APPLY #'CL:NCONC X)) (CL:SETF (CL:GETHASH '%NCONC *BUILTIN-ATOMS*) #'%NCONC))
  (CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1534 (TESTS) (CL:LABELS ((~G1535 (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)))) (~G1535 (CL:CAR (CL:LAST TESTS)))))) (~G1534 (GROUP BODY 2))))))
  (CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
  (CL:DEFUN SOLE? (X) (CL:BLOCK SOLE? (CL:BLOCK NIL (== 1 (CL:LENGTH X)))))
  (CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1536 (~G323) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1537 (~G324) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G323)) ~G324)) (~G1537 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY #'FORMAT NIL MSG ARGS))))))) (~G1536 *PRINT-AUTOMATIC-NEWLINE?*)))))
  (CL:DEFUN FORMAT (STR TXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1538 (~G320) (CL:LABELS ((~G1539 (NSTR) (CL:LABELS ((~G1540 (~G321) (CL:COND (~G320 ~G321) (T (GET-STREAM-STRING NSTR))))) (~G1540 (CL:PROGN (CL:LABELS ((~G1541 (~G319) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1542 (~G322) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G319)) ~G322)) (~G1542 (CL:PROGN (%FORMAT (MAKE-FORMAT-INFO :STREAM NSTR :TEXT TXT :ARGS ARGS) (STRING-LIST TXT) ARGS)))))) (~G1541 *PRINT-AUTOMATIC-NEWLINE?*))))))) (~G1539 (DEFAULT-STREAM ~G320))))) (~G1538 STR)))))
  (CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1543 (~G165) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G165)) (~G1543 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
  (CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
  (CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
  (CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
  (CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (CL:APPLY #'STRING-CONCAT (CL:MAPCAR (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((STRING? _) _) ((CHARACTER? _) (STRING _))))) (QUEUE-LIST X))))))
  (CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
  (CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1544 (L) (CL:LABELS ((~G1545 (S) (CL:BLOCK NIL (CL:LABELS ((~G1546 (I) (CL:TAGBODY ~G92 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G92)))) (~G1546 (-- L)))) S)) (~G1545 NIL)))) (~G1544 (CL:LENGTH X))))))
  (CL:DEFUN -- (X) (NUMBER- X 1))
  (CL:DEFUN MAKE-FORMAT-INFO (CL:&KEY (STREAM 'STREAM) (TEXT 'TEXT) (ARGS 'ARGS) (PROCESSED-ARGS 'PROCESSED-ARGS)) (CL:BLOCK MAKE-FORMAT-INFO (CL:BLOCK NIL (CL:LABELS ((~G1547 (~G317) (CL:PROGN (=-AREF 'STRUCT ~G317 0) (=-AREF 'FORMAT-INFO ~G317 1)) (CL:PROGN (=-AREF (CL:COND ((EQ STREAM 'STREAM) NIL) (T STREAM)) ~G317 2)) (CL:PROGN (=-AREF (CL:COND ((EQ TEXT 'TEXT) NIL) (T TEXT)) ~G317 3)) (CL:PROGN (=-AREF (CL:COND ((EQ ARGS 'ARGS) NIL) (T ARGS)) ~G317 4)) (CL:PROGN (=-AREF (CL:COND ((EQ PROCESSED-ARGS 'PROCESSED-ARGS) 0) (T PROCESSED-ARGS)) ~G317 5)) ~G317)) (~G1547 (MAKE-ARRAY 6))))))
  (CL:DEFUN %FORMAT (INF TXT ARGS) (CL:BLOCK %FORMAT (CL:BLOCK NIL (CL:COND (TXT (CL:PROGN (CL:COND ((CHARACTER== (CL:CAR TXT) #\~) (%FORMAT-DIRECTIVE INF (CL:CDR TXT) ARGS)) (T (CL:PROGN (PRINC (CL:CAR TXT) (FORMAT-INFO-STREAM INF)) (%FORMAT INF (CL:CDR TXT) ARGS))))))))))
  (CL:DEFUN FORMAT-INFO-STREAM (ARR) (CL:BLOCK FORMAT-INFO-STREAM (CL:BLOCK NIL (CL:AREF ARR 2))))
  (CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1548 (~G173) (CL:LABELS ((~G1549 (S) (CL:LABELS ((~G1550 (~G174) (CL:COND (~G173 ~G174) (T (GET-STREAM-STRING S))))) (~G1550 (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))))) (~G1549 (DEFAULT-STREAM ~G173))))) (~G1548 STR)))))
  (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 ((~G1551 (!) (CL:COND ((NOT (ZERO? !)) (CL:PROGN (PRINC #\. STR) (STREAM-PRINC (FRACTION-CHARS !) STR)))))) (~G1551 (CL:MOD X 1))))))
  (CL:DEFUN FRACTION-CHARS (X) (CL:BLOCK FRACTION-CHARS (CL:BLOCK NIL (FRACTION-CHARS-0 (CL:MOD (ABS X) 1)))))
  (CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
  (CL:DEFUN - (CL:&REST X) (CL:APPLY #'NUMBER- X))
  (CL:DEFUN FRACTION-CHARS-0 (X) (CL:BLOCK FRACTION-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1552 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT !) (FRACTION-CHARS-0 !)))))) (~G1552 (CL:MOD (* X 10) 10))))))
  (CL:DEFUN NUMBER-DIGIT (X) (CL:BLOCK NUMBER-DIGIT (CL:BLOCK NIL (CODE-CHAR (+ X #\0)))))
  (CL:DEFUN ZERO? (X) (CL:BLOCK ZERO? (CL:BLOCK NIL (== 0 X))))
  (CL:DEFUN INTEGER-CHARS (X) (CL:BLOCK INTEGER-CHARS (CL:BLOCK NIL (REVERSE (INTEGER-CHARS-0 (INTEGER (ABS X)))))))
  (CL:DEFUN INTEGER-CHARS-0 (X) (CL:BLOCK INTEGER-CHARS-0 (CL:BLOCK NIL (CL:LABELS ((~G1553 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 X) (INTEGER-CHARS-0 (/ (- X !) 10))))))) (~G1553 (INTEGER (CL:MOD X 10)))))))
  (CL:DEFUN <= (N CL:&REST X) (CL:BLOCK <= (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1554 (~G18) (CL:LABELS ((~G1555 (I) (CL:TAGBODY ~G16 (CL:COND ((NOT ~G18) (CL:GO ~G17))) (CL:SETQ I (CL:CAR ~G18)) (CL:LABELS ((~G1556 (~G14) (CL:COND (~G14 ~G14) (T (CL:LABELS ((~G1557 (~G15) (CL:COND (~G15 ~G15) (T (CL:RETURN-FROM NIL NIL))))) (~G1557 (< N I))))))) (~G1556 (== N I))) (CL:SETQ N I) (CL:SETQ ~G18 (CL:CDR ~G18)) (CL:GO ~G16) ~G17 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G1555 NIL)))) (~G1554 X))))))
  (CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G1558 (!) (CL:BLOCK NIL (CL:LABELS ((~G1559 (~G39) (CL:LABELS ((~G1560 (I) (CL:TAGBODY ~G37 (CL:COND ((NOT ~G39) (CL:GO ~G38))) (CL:SETQ I (CL:CAR ~G39)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G39 (CL:CDR ~G39)) (CL:GO ~G37) ~G38 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G1560 NIL)))) (~G1559 LST))))) (~G1558 NIL)))))
  (CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G1561 (~G162) (CL:LABELS ((~G1562 (!) (CL:TAGBODY ~G160 (CL:COND ((NOT ~G162) (CL:GO ~G161))) (CL:SETQ ! (CL:CAR ~G162)) (STREAM-PRINC ! STR) (CL:SETQ ~G162 (CL:CDR ~G162)) (CL:GO ~G160) ~G161 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G1562 NIL)))) (~G1561 X)))) (T (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)))))))))
  (CL:DEFUN STREAM-FUN-OUT (ARR) (CL:BLOCK STREAM-FUN-OUT (CL:BLOCK NIL (CL:AREF ARR 4))))
  (CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
  (CL:DEFUN %TRACK-LOCATION (STREAM-LOCATION X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1563 (STREAM-LOCATION) (CL:LABELS ((~G1564 (TRACK?) (CL:LABELS ((~G1565 (ID) (CL:LABELS ((~G1566 (LINE) (CL:LABELS ((~G1567 (COLUMN) (CL:LABELS ((~G1568 (TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:BLOCK NIL (CL:LABELS ((~G1569 (~G159) (CL:LABELS ((~G1570 (!) (CL:TAGBODY ~G157 (CL:COND ((NOT ~G159) (CL:GO ~G158))) (CL:SETQ ! (CL:CAR ~G159)) (%TRACK-LOCATION STREAM-LOCATION !) (CL:SETQ ~G159 (CL:CDR ~G159)) (CL:GO ~G157) ~G158 (CL:RETURN-FROM NIL (CL:PROGN NIL))))) (~G1570 NIL)))) (~G1569 (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)) (~G1568 (STREAM-LOCATION-TABSIZE STREAM-LOCATION))))) (~G1567 (STREAM-LOCATION-COLUMN STREAM-LOCATION))))) (~G1566 (STREAM-LOCATION-LINE STREAM-LOCATION))))) (~G1565 (STREAM-LOCATION-ID STREAM-LOCATION))))) (~G1564 (STREAM-LOCATION-TRACK? STREAM-LOCATION))))) (~G1563 STREAM-LOCATION)))))
  (CL:DEFUN NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (++ (* SIZE (++ (INTEGER (/ (-- COLUMN) SIZE))))))))
  (CL:DEFUN ++ (X) (NUMBER+ X 1))
  (CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
  
negative.code: (CL:DEFVAR *ENVIRONMENT-PATH*)
  (CL:DEFVAR *ENVIRONMENT-FILENAMES*)
  (CL:PROGN (CL:DEFUN ENV-LOAD (PATHNAME CL:&OPTIONAL (TARGET NIL)) (CL:SETQ *ENVIRONMENT-FILENAMES* (CL:CONS (CL:CONS PATHNAME TARGET) *ENVIRONMENT-FILENAMES*)) (LOAD (+ *ENVIRONMENT-PATH* "/environment/" PATHNAME))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) #'ENV-LOAD))
  (CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G1496 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADAR X)))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G1496 (GENSYM))))
  (CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G1497 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G1497 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
  (CL:DEFUN LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (CL:ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
  (CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((CL:ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-WITHOUT-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (CL:MAPCAR #'MAKE-LAMBDAS X))))
  (CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
  (CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (TRE2CL X))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) #'EVAL))
  (CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G1498 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G1499 (~G1451) (CL:BLOCK NIL (CL:LABELS ((~G1500 (!) (CL:TAGBODY ~G1452 (CL:COND ((INTEGER== ! ~G1451) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (%PRINC (CL:ELT X !) STREAM) (CL:SETQ ! (INTEGER+ 1 !)) (CL:GO ~G1452)))) (~G1500 0))))) (~G1499 (INTEGER (CL:LENGTH X))))) (T (CL:PRINC X !))))) (~G1498 (CL:LABELS ((~G1501 (~G1450) (CL:COND (~G1450 ~G1450) (T CL:*STANDARD-OUTPUT*)))) (~G1501 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) #'%PRINC))
  (CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) #'%FORCE-OUTPUT))
  (CL:PROGN (CL:DEFUN %FOPEN (PATHNAME MODE) (CL:OPEN PATHNAME :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST #'CL:EQUAL) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) #'%FOPEN))
  (CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) #'%FCLOSE))
  (CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G1502 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G1502 (CL:READ-BYTE (CL:LABELS ((~G1503 (~G1453) (CL:COND (~G1453 ~G1453) (T CL:*STANDARD-INPUT*)))) (~G1503 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) #'%READ-CHAR))
  (CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:ENSURE-DIRECTORIES-EXIST PATHNAME)) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) #'UNIX-SH-MKDIR))
  (CL:DEFVAR *FUNCTIONS*)
  (CL:PROGN (CL:DEFUN FUNCTION-NATIVE (X) X) (CL:SETF (CL:GETHASH 'FUNCTION-NATIVE *BUILTIN-ATOMS*) #'FUNCTION-NATIVE))
  (CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:LABELS ((~G1504 (~G1454) (CL:COND (~G1454 ~G1454) (T (CL:ERROR "Not a function."))))) (~G1504 (CL:FUNCTIONP X))) (CL:GETHASH X *FUNCTIONS*)) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) #'FUNCTION-SOURCE))
  (CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (CL:SETF (CL:GETHASH X *FUNCTIONS*) V)) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) #'=-FUNCTION-SOURCE))
  (CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) #'FUNCTION-BYTECODE))
  (CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST #'EQL)) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST #'EQ) #'CL:EQ) ((CL:LABELS ((~G1505 (~G1455) (CL:COND (~G1455 ~G1455) (T (CL:EQ TEST #'==))))) (~G1505 (CL:EQ TEST #'EQL))) #'CL:EQL) ((CL:EQ TEST #'STRING==) #'CL:EQUAL) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) #'MAKE-HASH-TABLE))
  (CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) #'HASH-TABLE?))
  (CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) #'HREF))
  (CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) #'=-HREF))
  (CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) #'HREMOVE))
  (CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G1506 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G1506 (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*) #'COPY-HASH-TABLE))
  (CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G1507 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G1507 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) #'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*) #'SYS-IMAGE-CREATE))
  (CL:PROGN (CL:DEFUN %START-CORE NIL (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G1508 (~G1457) (CL:COND (~G1457 ~G1457) (T NIL)))) (~G1508 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) #'%START-CORE))
  (CL:DEFVAR *DEFAULT-LISTPROP*)
  (CL:PROGN (CL:DEFUN CPR (X) X NIL) (CL:SETF (CL:GETHASH 'CPR *BUILTIN-ATOMS*) #'CPR))
  (CL:PROGN (CL:DEFUN RPLACP (V X) X V) (CL:SETF (CL:GETHASH 'RPLACP *BUILTIN-ATOMS*) #'RPLACP))
  