anchor.diff:  
   (defun random-bits (count)
     "Return an integer containing COUNT random bits."
  -  (with-/dev/random (s)
  -    (cond ((>= *remainder-bits* count)
  -           (prog1 (logand (1- (ash 1 count)) *remainder*)
  -             (setf *remainder* (ash *remainder* (- count)))
  -             (decf *remainder-bits* count)))
  -          (t (let* ((full-bytes (floor (- count *remainder-bits*) 8))
  -                    (last-byte-bits (- count *remainder-bits* (* 8 full-bytes))))
  -               (with-shift-in
  -                 (shift-in *remainder* *remainder-bits*)
  -                 (dotimes (i full-bytes)
  -                   (shift-in (random-byte) 8))
  -                 (cond ((> last-byte-bits 0)
  -                        (let ((last-byte (random-byte)))
  -                          (shift-in (logand last-byte (1- (ash 1 last-byte-bits)))
  -                                    last-byte-bits)
  -                          (setf *remainder* (ash last-byte (- last-byte-bits))
  -                                *remainder-bits* (- 8 last-byte-bits))))
  -                       (t (setf *remainder* 0
  -                                *remainder-bits* 0)))
  -                 (shift-value)))))))
  +  (with-/dev/random (s) (%random-bits count s)))
  +
  +(defun %random-bits (count s)
  +  (cond ((>= *remainder-bits* count)
  +         (prog1 (logand (1- (ash 1 count)) *remainder*)
  +           (setf *remainder* (ash *remainder* (- count)))
  +           (decf *remainder-bits* count)))
  +        (t (let* ((full-bytes (floor (- count *remainder-bits*) 8))
  +                  (last-byte-bits (- count *remainder-bits* (* 8 full-bytes))))
  +             (with-shift-in
  +               (shift-in *remainder* *remainder-bits*)
  +               (dotimes (i full-bytes)
  +                 (shift-in (%random-byte s) 8))
  +               (cond ((> last-byte-bits 0)
  +                      (let ((last-byte (%random-byte s)))
  +                        (shift-in (logand last-byte (1- (ash 1 last-byte-bits)))
  +                                  last-byte-bits)
  +                        (setf *remainder* (ash last-byte (- last-byte-bits))
  +                              *remainder-bits* (- 8 last-byte-bits))))
  +                     (t (setf *remainder* 0
  +                              *remainder-bits* 0)))
  +               (shift-value))))))
   
   ;; Can't just get COUNT bits and reduce to LIMIT's range.
   ;; That makes some values more likely than others.
  
positive.code:   "Return a random integer >= 0 and < limit. Same as `cl:random', but better randomness."
    (check-type limit (integer 0))
    (when (eql limit 0) (return-from random-integer 0))
    (with-/dev/random ()
      (loop with count = (integer-length limit)
         for bits = (random-bits count)
         when (< bits limit) return bits)))
  
  )
  
negative.code: 
  (defun random-byte ()
    "Return one random byte."
    (with-/dev/random (s) (%random-byte s)))
  
  (defun %random-byte (s)
    (read-byte s))
  
  (defun %shift-in (accum fix-accum fix-accum-bits fix-accum-size value bits)
    (cond ((>= (+ fix-accum-bits bits) fix-accum-size)
  