anchor.diff:              let arrSize = leftOnBuffer + leftOnStream
               let bytes   = Array.zeroCreate<byte> arrSize
   
  -            // read the bytes left on the buffer
               for idx = bufferIdx to bufferSize-1 do
                   bytes.[idx - bufferIdx] <- buffer.[idx]
   
  -            // then read bytes left on the stream
               if stream.Read(bytes, leftOnBuffer, leftOnStream) <> leftOnStream then
                   raise InsufficientBytes
   
               if bufferBytePos = 0 then bytes
  -            else [||]
  +            else // if we're starting off with a partly consumed byte, then we'll need to 
  +                 // offset the bits in each byte
  +                 // e.g. 10|01000100|01011100|(padding)
  +                 // becomes 01000100|01011100|(padding, hence the Seq.take and Seq.toArray)
  +                 offset bufferBytePos bytes
  +                 |> Seq.take (arrSize - 1)
  +                 |> Seq.toArray
   
           let readFrom (Reader(count, convert)) =
               match count with
  
positive.code:             loop count 0 0
  
          let readRest () =
              if bufferBytePos = 8 then 
                  bufferBytePos <- 0
                  bufferIdx     <- bufferIdx + 1
  
              let leftOnBuffer = bufferSize - bufferIdx
              let leftOnStream = stream.Length - stream.Position |> int
  
negative.code:         let mutable bufferIdx     = 0
          let mutable bufferBytePos = 0
  
          let incrBufferIdx () =
              if bufferBytePos = 8 then 
                  bufferBytePos <- 0
                  bufferIdx     <- bufferIdx + 1
  
          let readIntoBuffer () =
              match stream.Read(buffer, 0, defaultBufferSize) with
              | -1 -> raise InsufficientBytes
  