anchor.diff:  (defun bits (int &key big-endian)
     "Return a bit vector of the bits in INT.
   Defaults to little-endian."
  -  (lret ((bits (make-array (integer-length int)
  -                           :element-type 'bit)))
  +  (let ((bits (make-array (integer-length int)
  +                          :element-type 'bit)))
       (if big-endian
           (loop for i below (integer-length int)
                 for j downfrom (1- (integer-length int)) to 0
  
positive.code:        (setf ,place (- ,old ,delta))
         ,old)))
  
  (defun parse-float (string &key (start 0) (end (length string)) junk-allowed)
    "Based on the venerable `parse-float' from the CMU Lisp repository.
  Of course you could just use `parse-number', but sometimes only a
  float will do."
    (declare (string string) (array-length start end))
    (let ((index (or (position-if-not #'whitespacep string
                                      :start start :end end)
                     (return-from parse-float (values 0.0 end))))
          (minusp nil) (decimalp nil) (found-digit nil)
          (before-decimal 0) (after-decimal 0) (decimal-counter 0)
          (exponent 0)
          (result 0)
          (radix 10))
      (declare (array-length index))
      (let ((char (char string index)))
        (cond ((char= char #\-)
               (setq minusp t)
               (incf index))
              ((char= char #\+)
               (incf index))))
      (loop
        until (= index end)
        for char = (char string index)
        as weight = (digit-char-p char radix)
        do (cond ((and weight (not decimalp))
                  (setq before-decimal (+ weight (* before-decimal radix))
                        found-digit t))
                 ((and weight decimalp)
                  (setq after-decimal (+ weight (* after-decimal radix))
                        found-digit t)
                  (incf decimal-counter))
                 ((and (char= char #\.) (not decimalp))
                  (setq decimalp t))
                 ((and (case char ((#\e #\d #\f #\s #\l) t))
                       (= radix 10))
                  (multiple-value-bind (num idx)
                      (parse-integer string :start (1+ index) :end end
                                            :radix radix :junk-allowed junk-allowed)
                    (setq exponent (or num 0)
                          index idx)
                    (when (= index end) (return nil))))
                 ((whitespacep char)
                  (when (position-if-not #'whitespacep string
                                         :start (1+ index) :end end)
                    (if junk-allowed
                        (loop-finish)
                        (error "There's junk in this string: ~s." string)))
                  (return nil))
                 (t (if junk-allowed
                        (loop-finish)
                        (error "There's junk in this string: ~s." string))))
           (incf index))
      (setq result (coerce (* (+ before-decimal
                                 (* after-decimal
                                    (coerce (expt radix (- decimal-counter))
                                            'float)))
                              (coerce (expt radix exponent)
                                      'float))
                           'float))
      (values
       (if found-digit
           (if minusp (- result) result)
           0.0)
       index)))
  
  (declaim (inline round-to))
  (defun round-to (number &optional (divisor 1))
  
negative.code: 
  (define-modify-macro growf (n) grow
    "Grow the value in a place by a factor.")
  
  (declaim (inline random-in-range))
  (defun random-in-range (low high)
    "Random number in the range [low,high).
  
  From Zetalisp."
  