anchor.diff:    (funcall (%bitio/read-octet bitio)
              (octet-stream bitio)
              eof-error-p eof-value))
  -
  -;; Axion's old code.
  -(defun read-integer (byte-buffer &key (bytes 1) (bit-width 8) (unsignedp t) (endian :be))
  -  (let ((value 0))
  -    (ecase endian
  -      (:be (loop :for i :from (* (1- bytes) bit-width) :downto 0 :by bit-width
  -                 :for byte = (fast-io:fast-read-byte byte-buffer)
  -                 :do (setf (ldb (byte bit-width i) value) byte)))
  -      (:le (loop :for i :below (* bit-width bytes) :by bit-width
  -                 :for byte = (fast-io:fast-read-byte byte-buffer)
  -                 :do (setf (ldb (byte bit-width i) value) byte))))
  -    (if unsignedp
  -        value
  -        (logior (* (ldb (byte 1 (1- bytes)) value)
  -                   (- (expt 2 (* bytes bit-width))))
  -                value))))
   
   ;; Assumptions:
   ;; 1) The individual bits of an octet have canonical positions of:
  
positive.code:   ((%octet-stream :initarg :octet-stream
                    :initform NIL
                    :reader octet-stream)
     ;; bit-stable is an unsigned integer that holds unprocessed
     ;; bits always in canonical ordering. However, depending on what
     ;; we're doing we might take bits from the MSB side or the LSB
     ;; side. The bit-stable is an octet worth of bits or less. Though
     ;; this may change in the future.
     (%bit-stable :initarg :bit-stable
                  :initform 0
                  :accessor bit-stable)
     ;; How many bits are currently in the stable.
     (%num-bits-in-stable :initarg :num-bits-in-stable
                          :initform 0
  
negative.code:       ;; Oops, had an EOF
        ((equal result eof-value)
         (setf (num-bits-in-stable bitio) 0
               (read-bit-stable bitio) 0)
         NIL)
        ;; all good.
        (t
         (setf (num-bits-in-stable bitio) 8
               (read-bit-stable bitio) result)
         T))))
  
  ;; This is not entirely a fast-path since it doesn't read a sequence.
  (defun fast-path/octet-aligned-bit-read (bitio bit-read-count bit-endian
                                           &optional (eof-error-p T)
                                             (eof-value NIL))
    "This function assumes the read-bit-stable is empty in the BITIO stream
  and BIT-READ-COUNT is a multiple of 8.  It reads BIT-READ-COUNT bits
  from the BITIO stream (reading the actual bits in each octet in
  BIT-ENDIAN manner) and then places them into an integer that it returns.
  