diff --git a/bitpacker/src/bitpacker.rs b/bitpacker/src/bitpacker.rs
index e022e33e9..716f865f9 100644
--- a/bitpacker/src/bitpacker.rs
+++ b/bitpacker/src/bitpacker.rs
@@ -82,14 +82,16 @@ impl BitUnpacker {
         }
     }
 
+    pub fn bit_width(&self) -> u8 {
+        self.num_bits as u8
+    }
+
     #[inline]
     pub fn get(&self, idx: u64, data: &[u8]) -> u64 {
         if self.num_bits == 0 {
             return 0u64;
         }
-        let num_bits = self.num_bits;
-        let mask = self.mask;
-        let addr_in_bits = idx * num_bits;
+        let addr_in_bits = idx * self.num_bits;
         let addr = addr_in_bits >> 3;
         let bit_shift = addr_in_bits & 7;
         debug_assert!(
@@ -101,7 +103,7 @@ impl BitUnpacker {
             .unwrap();
         let val_unshifted_unmasked: u64 = u64::from_le_bytes(bytes);
         let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
-        val_shifted & mask
+        val_shifted & self.mask
     }
 }
 
diff --git a/fastfield_codecs/benches/bench.rs b/fastfield_codecs/benches/bench.rs
index 8afe5d973..af6a58dff 100644
--- a/fastfield_codecs/benches/bench.rs
+++ b/fastfield_codecs/benches/bench.rs
@@ -33,9 +33,13 @@ mod tests {
         S::serialize(&mut bytes, &data).unwrap();
         let reader = R::open_from_bytes(OwnedBytes::new(bytes)).unwrap();
         b.iter(|| {
+            let mut sum = 0u64;
             for pos in value_iter() {
-                reader.get_u64(pos as u64);
+                let val = reader.get_u64(pos as u64);
+                debug_assert_eq!(data[pos as usize], val);
+                sum = sum.wrapping_add(val);
             }
+            sum
         });
     }
     fn bench_create<S: FastFieldCodecSerializer>(b: &mut Bencher, data: &[u64]) {
diff --git a/fastfield_codecs/src/blockwise_linear.rs b/fastfield_codecs/src/blockwise_linear.rs
index c65317096..bab1581fe 100644
--- a/fastfield_codecs/src/blockwise_linear.rs
+++ b/fastfield_codecs/src/blockwise_linear.rs
@@ -19,7 +19,7 @@ use tantivy_bitpacker::{compute_num_bits, BitPacker, BitUnpacker};
 
 use crate::linear::{get_calculated_value, get_slope};
 use crate::{
-    FastFieldCodecReader, FastFieldCodecSerializer, FastFieldCodecType, FastFieldDataAccess,
+    FastFieldCodecReader, FastFieldCodecSerializer, FastFieldCodecType, FastFieldDataAccess, blockwise_linear,
 };
 
 const CHUNK_SIZE: u64 = 512;
@@ -159,14 +159,14 @@ impl FastFieldCodecReader for BlockwiseLinearReader {
     }
 
     #[inline]
-    fn get_u64(&self, doc: u64) -> u64 {
-        let interpolation = get_interpolation_function(doc, &self.footer.interpolations);
-        let doc = doc - interpolation.start_pos;
+    fn get_u64(&self, idx: u64) -> u64 {
+        let interpolation = get_interpolation_function(idx, &self.footer.interpolations);
+        let in_block_idx = idx - interpolation.start_pos;
         let calculated_value =
-            get_calculated_value(interpolation.value_start_pos, doc, interpolation.slope);
+            get_calculated_value(interpolation.value_start_pos, in_block_idx, interpolation.slope);
         let diff = interpolation
             .bit_unpacker
-            .get(doc, &self.data[interpolation.data_start_offset as usize..]);
+            .get(in_block_idx, &self.data[interpolation.data_start_offset as usize..]);
         (calculated_value + diff) - interpolation.positive_val_offset
     }