anchor.diff:           (byte-specification (byte num-selected-bits bit-start-position)))
   
       #++(format t "bs: ~8,'0B, n-s-b: ~A, b-s-p: ~A, b-s: ~A~%"
  -               (bit-stable bitio)
  +               (read-bit-stable bitio)
                  num-selected-bits bit-start-position byte-specification)
   
       (let ((value 0))
         ;; First, we grab the bits we need out of the stable and put them in
         ;; the :le end of the value
  -      (setf value (ldb byte-specification (bit-stable bitio)))
  +      (setf value (ldb byte-specification (read-bit-stable bitio)))
         ;; Then, depending on bit endian, we clean up the value and bit stable.
         (case bit-endian
           (:le
            ;; Shift the bit stable to the right by the number of bits I collected.
            ;; This gets rid of those bits in the stable.
  -         (setf (bit-stable bitio)
  -               (ash (bit-stable bitio) (- num-selected-bits)))
  +         (setf (read-bit-stable bitio)
  +               (ash (read-bit-stable bitio) (- num-selected-bits)))
            ;; Then reverse the bits, cause they are to come out in :le order
            (let ((result (integer-reverse value num-selected-bits)))
              ;; remove the accounting of the bits from the stable.
  
positive.code:           ;; from the stable once it has been filled.
            (multiple-value-bind (suffix-stable-bits
                                  num-suffix-stable-bits-read)
                (consume-bit-stable bitio bits-remaining-to-read bit-endian)
  
              ;; Now, we have three groups of bits, assemble them into the
              ;; answer we seek.
  
negative.code: 
          (:be
           ;; Zero out the :be stable bits we just took out.
           (setf (ldb byte-specification (read-bit-stable bitio))
                 0)
           ;; remove the accounting of the bits from the stable.
           (decf (num-bits-in-stable bitio) num-selected-bits)
  