From 054107c2fa1b6a5ac6495a10b119cdbd50ca9f64 Mon Sep 17 00:00:00 2001
From: zenotme <st810918843@gmail.com>
Date: Thu, 19 Feb 2026 20:40:48 +0800
Subject: [PATCH 1/8] refactor(theta): introduce ThetaSketchView trait and
 enhance ThetaHashTable used for set operation

---
 datasketches/src/theta/hash_table.rs | 264 +++++++++++++++++----------
 datasketches/src/theta/mod.rs        |   1 +
 datasketches/src/theta/sketch.rs     | 112 ++++++++++--
 3 files changed, 264 insertions(+), 113 deletions(-)

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index d77304e..967e2c5 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -37,7 +37,7 @@ pub const DEFAULT_LG_K: u8 = 12;
 const RESIZE_THRESHOLD: f64 = 0.5;
 
 /// Rebuild threshold (15/16 = 93.75% load factor)
-const REBUILD_THRESHOLD: f64 = 15.0 / 16.0;
+pub(crate) const REBUILD_THRESHOLD: f64 = 15.0 / 16.0;
 
 /// Stride hash bits (7 bits for stride calculation)
 const STRIDE_HASH_BITS: u8 = 7;
@@ -61,10 +61,16 @@ pub(crate) struct ThetaHashTable {
     sampling_probability: f32,
     hash_seed: u64,
 
+    // Logical emptiness of the source set. This can be false even when `num_retained` is 0 (e.g.
+    // all updates screened by theta).
+    is_empty: bool,
+
     theta: u64,
 
     entries: Vec<u64>,
-    num_entries: usize,
+
+    // Number of retained non-zero hashes currently stored in `entries`.
+    num_retained: usize,
 }
 
 impl ThetaHashTable {
@@ -77,34 +83,58 @@ impl ThetaHashTable {
     ) -> Self {
         let lg_max_size = lg_nom_size + 1;
         let lg_cur_size = starting_sub_multiple(lg_max_size, MIN_LG_K, resize_factor.lg_value());
+        Self::new_with_state(
+            lg_cur_size,
+            lg_nom_size,
+            resize_factor,
+            sampling_probability,
+            starting_theta_from_sampling_probability(sampling_probability),
+            hash_seed,
+            true,
+        )
+    }
+
+    /// Create a table with explicit state.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `lg_cur_size > lg_nom_size + 1`. (`lg_nom_size + 1 == lg_max_size`)
+    pub fn new_with_state(
+        lg_cur_size: u8,
+        lg_nom_size: u8,
+        resize_factor: ResizeFactor,
+        sampling_probability: f32,
+        theta: u64,
+        hash_seed: u64,
+        is_empty: bool,
+    ) -> Self {
+        let lg_max_size = lg_nom_size + 1;
+        assert!(
+            lg_cur_size <= lg_max_size,
+            "lg_cur_size must be <= lg_nom_size + 1, got lg_cur_size={lg_cur_size}, lg_nom_size={lg_nom_size}"
+        );
         let size = if lg_cur_size > 0 { 1 << lg_cur_size } else { 0 };
         let entries = vec![0u64; size];
-
         Self {
             lg_cur_size,
             lg_nom_size,
             lg_max_size,
             resize_factor,
             sampling_probability,
-            theta: starting_theta_from_sampling_probability(sampling_probability),
             hash_seed,
+            is_empty,
+            theta,
             entries,
-            num_entries: 0,
+            num_retained: 0,
         }
     }
 
-    /// Hash and screen a value
-    ///
-    /// Returns the hash value if it passes the theta threshold, otherwise 0.
-    pub fn hash_and_screen<T: Hash>(&mut self, value: T) -> u64 {
+    /// Hash a value with the table seed and return the hash.
+    pub fn hash<T: Hash>(&self, value: T) -> u64 {
         let mut hasher = MurmurHash3X64128::with_seed(self.hash_seed);
         value.hash(&mut hasher);
         let (h1, _) = hasher.finish128();
-        let hash = h1 >> 1; // To make it compatible with Java version
-        if hash >= self.theta {
-            return 0; // hash == 0 is reserved for empty slots
-        }
-        hash
+        h1 >> 1 // To make it compatible with Java version
     }
 
     /// Find an entry in the hash table.
@@ -142,11 +172,21 @@ impl ThetaHashTable {
         }
     }
 
-    /// Insert a hash value into the table
+    /// Hashes and inserts a value into the table.
     ///
     /// Returns true if the value was inserted (new), false otherwise.
-    pub fn try_insert(&mut self, hash: u64) -> bool {
-        if hash == 0 {
+    pub fn try_insert<T: Hash>(&mut self, value: T) -> bool {
+        let hash = self.hash(value);
+        self.try_insert_hash(hash)
+    }
+
+    /// Inserts a pre-hashed value into the table.
+    ///
+    /// Returns true if the value was inserted (new), false otherwise.
+    pub fn try_insert_hash(&mut self, hash: u64) -> bool {
+        self.is_empty = false;
+
+        if hash == 0 || hash >= self.theta {
             return false;
         }
 
@@ -163,11 +203,11 @@ impl ThetaHashTable {
 
         assert_eq!(self.entries[index], 0, "Entry should be empty");
         self.entries[index] = hash;
-        self.num_entries += 1;
+        self.num_retained += 1;
 
         // Check if we need to resize or rebuild
         let capacity = self.get_capacity();
-        if self.num_entries > capacity {
+        if self.num_retained > capacity {
             if self.lg_cur_size <= self.lg_nom_size {
                 self.resize();
             } else {
@@ -242,13 +282,13 @@ impl ThetaHashTable {
             num_inserted, k as usize,
             "Number of inserted entries should be equal to k."
         );
-        self.num_entries = num_inserted;
+        self.num_retained = num_inserted;
         self.entries = new_entries;
     }
 
     /// Trim the table to nominal size k
     pub fn trim(&mut self) {
-        if self.num_entries > (1 << self.lg_nom_size) {
+        if self.num_retained > (1 << self.lg_nom_size) {
             self.rebuild();
         }
     }
@@ -267,14 +307,15 @@ impl ThetaHashTable {
             self.entries.resize(1 << init_lg_cur, 0);
         }
         self.entries.fill(0);
-        self.num_entries = 0;
+        self.num_retained = 0;
         self.theta = init_theta;
+        self.is_empty = true;
         self.lg_cur_size = init_lg_cur;
     }
 
-    /// Get number of entries
-    pub fn num_entries(&self) -> usize {
-        self.num_entries
+    /// Return number of retained entries
+    pub fn num_retained(&self) -> usize {
+        self.num_retained
     }
 
     /// Get theta
@@ -282,9 +323,9 @@ impl ThetaHashTable {
         self.theta
     }
 
-    /// Check if empty
+    /// Check if emptiness of the source set
     pub fn is_empty(&self) -> bool {
-        self.num_entries == 0
+        self.is_empty
     }
 
     /// Get iterator over entries
@@ -302,6 +343,55 @@ impl ThetaHashTable {
         compute_seed_hash(self.hash_seed)
     }
 
+    /// Returns true if the given hash exists in the table.
+    #[allow(dead_code)]
+    pub fn contains_hash(&self, hash: u64) -> bool {
+        if hash == 0 {
+            return false;
+        }
+        let Some(index) = self.find_in_curr_entries(hash) else {
+            return false;
+        };
+        self.entries[index] == hash
+    }
+
+    /// Set empty flag
+    #[allow(dead_code)]
+    pub fn set_empty(&mut self, is_empty: bool) {
+        self.is_empty = is_empty;
+    }
+
+    /// Get the hash seed used by this table.
+    #[allow(dead_code)]
+    pub fn hash_seed(&self) -> u64 {
+        self.hash_seed
+    }
+
+    /// Sets theta value.
+    #[allow(dead_code)]
+    pub fn set_theta(&mut self, theta: u64) {
+        assert!(
+            (1..=MAX_THETA).contains(&theta),
+            "theta must be in [1, {MAX_THETA}], got {theta}"
+        );
+        self.theta = theta;
+    }
+
+    /// Returns minimal lg_size where rebuild-capacity can hold `count`.
+    #[allow(dead_code)]
+    pub fn lg_size_from_count_for_rebuild(count: usize, load_factor: f64) -> u8 {
+        let log2 = |n: usize| {
+            if n == 0 { 0_u8 } else { n.ilog2() as u8 }
+        };
+        let log2_n = log2(count);
+        log2_n
+            + (if count > (((1u128 << ((log2_n as u32) + 1)) as f64) * load_factor) as usize {
+                2
+            } else {
+                1
+            })
+    }
+
     /// Get stride for hash table probing
     fn get_stride(key: u64, lg_size: u8) -> usize {
         (2 * ((key >> (lg_size)) & STRIDE_MASK) + 1) as usize
@@ -344,46 +434,43 @@ mod tests {
             starting_sub_multiple(8 + 1, MIN_LG_K, ResizeFactor::X8.lg_value())
         );
         assert_eq!(table.theta, starting_theta_from_sampling_probability(1.0));
-        assert_eq!(table.num_entries(), 0);
+        assert_eq!(table.num_retained(), 0);
         assert!(table.is_empty());
         assert_eq!(table.iter().count(), 0);
     }
 
     #[test]
-    fn test_hash_and_screen() {
+    fn test_hash_and_theta_screen_behavior() {
         let mut table = ThetaHashTable::new(8, ResizeFactor::X8, 1.0, DEFAULT_UPDATE_SEED);
 
-        // With MAX_THETA, all hashes should pass
-        let hash1 = table.hash_and_screen("test1");
-        let hash2 = table.hash_and_screen("test2");
+        // With MAX_THETA, hashes are computed normally.
+        let hash1 = table.hash("test1");
+        let hash2 = table.hash("test2");
         assert_ne!(hash1, 0);
         assert_ne!(hash2, 0);
         assert_ne!(hash1, hash2);
 
-        // With low theta, some hashes should be filtered
+        // With low theta, update should be screened out.
         table.theta = 1;
-        let hash3 = table.hash_and_screen("test3");
-        assert_eq!(hash3, 0);
+        assert!(!table.try_insert("test3"));
     }
 
     #[test]
     fn test_try_insert() {
         let mut table = ThetaHashTable::new(5, ResizeFactor::X8, 1.0, DEFAULT_UPDATE_SEED);
 
-        // Insert a hash value
-        let hash = table.hash_and_screen("test_value");
-        assert_ne!(hash, 0);
-        assert!(table.try_insert(hash));
-        assert_eq!(table.num_entries(), 1);
+        assert!(table.try_insert("test_value"));
+        assert_eq!(table.num_retained(), 1);
         assert!(!table.is_empty());
 
-        // Try to insert the same hash again (should fail)
-        assert!(!table.try_insert(hash));
-        assert_eq!(table.num_entries(), 1);
+        // Try to insert the same value again (should fail)
+        assert!(!table.try_insert("test_value"));
+        assert_eq!(table.num_retained(), 1);
 
-        // Try to insert 0 (should fail)
-        assert!(!table.try_insert(0));
-        assert_eq!(table.num_entries(), 1);
+        // Force screening and verify insertion fails
+        table.theta = 0;
+        assert!(!table.try_insert("screened"));
+        assert_eq!(table.num_retained(), 1);
     }
 
     #[test]
@@ -393,13 +480,12 @@ mod tests {
         // Insert multiple distinct values
         let mut inserted_count = 0;
         for i in 0..10 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 && table.try_insert(hash) {
+            if table.try_insert(format!("value_{}", i)) {
                 inserted_count += 1;
             }
         }
 
-        assert_eq!(table.num_entries(), inserted_count);
+        assert_eq!(table.num_retained(), inserted_count);
         assert!(!table.is_empty());
         assert_eq!(table.iter().count(), inserted_count);
     }
@@ -409,8 +495,7 @@ mod tests {
         fn populate_values(table: &mut ThetaHashTable, count: usize) -> usize {
             let mut inserted = 0;
             for i in 0..count {
-                let hash = table.hash_and_screen(format!("value_{}", i));
-                if hash != 0 && table.try_insert(hash) {
+                if table.try_insert(format!("value_{}", i)) {
                     inserted += 1;
                 }
             }
@@ -427,8 +512,8 @@ mod tests {
             let inserted = populate_values(&mut table, 20);
 
             // Table should have resized and all values should be inserted
-            assert!(table.num_entries() > 0);
-            assert_eq!(table.num_entries(), inserted);
+            assert!(table.num_retained() > 0);
+            assert_eq!(table.num_retained(), inserted);
             assert_eq!(table.entries.len(), 64);
         }
 
@@ -443,8 +528,8 @@ mod tests {
             let inserted = populate_values(&mut table, 20);
 
             // Table should have resized and all values should be inserted
-            assert!(table.num_entries() > 0);
-            assert_eq!(table.num_entries(), inserted);
+            assert!(table.num_retained() > 0);
+            assert_eq!(table.num_retained(), inserted);
             assert_eq!(table.entries.len(), 128);
         }
     }
@@ -459,10 +544,7 @@ mod tests {
 
         // Insert many values to trigger rebuild
         for i in 0..100 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
         // After rebuild, theta should be reduced (rebuild is called automatically during insert)
@@ -474,10 +556,7 @@ mod tests {
 
         // Continue to insert values to trigger rebuild again
         for i in 100..200 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
         assert_eq!(table.lg_cur_size, 6);
@@ -491,17 +570,14 @@ mod tests {
 
         // Insert more than k values
         for i in 0..100 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
-        let before_trim = table.num_entries();
+        let before_trim = table.num_retained();
         assert!(before_trim > 32);
 
         table.trim();
-        let after_trim = table.num_entries();
+        let after_trim = table.num_retained();
         assert!(after_trim <= 32);
         assert!(table.theta() < MAX_THETA);
     }
@@ -512,16 +588,13 @@ mod tests {
 
         // Insert fewer than k values
         for i in 0..10 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
-        let before_trim = table.num_entries();
+        let before_trim = table.num_retained();
         let before_theta = table.theta();
         table.trim();
-        let after_trim = table.num_entries();
+        let after_trim = table.num_retained();
 
         // Should not change if already <= k
         assert_eq!(before_trim, after_trim);
@@ -537,20 +610,17 @@ mod tests {
 
         // Insert some values
         for i in 0..10 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
         assert!(!table.is_empty());
-        assert!(table.num_entries() > 0);
+        assert!(table.num_retained() > 0);
 
         // Reset
         table.reset();
 
         assert!(table.is_empty());
-        assert_eq!(table.num_entries(), 0);
+        assert_eq!(table.num_retained(), 0);
         assert_eq!(table.theta(), init_theta);
         assert_eq!(table.lg_cur_size, init_lg_cur);
         assert_eq!(table.entries.len(), init_entries);
@@ -569,10 +639,7 @@ mod tests {
 
         // Insert some values
         for i in 0..10 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 {
-                table.try_insert(hash);
-            }
+            let _ = table.try_insert(format!("value_{}", i));
         }
 
         table.reset();
@@ -589,15 +656,15 @@ mod tests {
         // Insert some values
         let mut inserted_hashes = Vec::new();
         for i in 0..10 {
-            let hash = table.hash_and_screen(format!("value_{}", i));
-            if hash != 0 && table.try_insert(hash) {
+            let hash = table.hash(i);
+            if table.try_insert(i) {
                 inserted_hashes.push(hash);
             }
         }
 
         // Check iterator
         let iter_hashes: Vec<u64> = table.iter().collect();
-        assert_eq!(iter_hashes.len(), table.num_entries());
+        assert_eq!(iter_hashes.len(), table.num_retained());
         assert_eq!(iter_hashes.len(), inserted_hashes.len());
 
         // All inserted hashes should be in iterator
@@ -614,7 +681,7 @@ mod tests {
         let mut table = ThetaHashTable::new(8, ResizeFactor::X8, 1.0, DEFAULT_UPDATE_SEED);
 
         assert!(table.is_empty());
-        assert_eq!(table.num_entries(), 0);
+        assert_eq!(table.num_retained(), 0);
         assert_eq!(table.iter().count(), 0);
 
         // Trim on empty table should not panic
@@ -635,13 +702,12 @@ mod tests {
         let mut i = 0;
         let mut inserted_hashes = Vec::new();
         loop {
-            let hash = table.hash_and_screen(format!("value_{}", i));
+            let hash = table.hash(i);
             i += 1;
-            if hash != 0 {
-                table.try_insert(hash);
+            if table.try_insert(i - 1) {
                 inserted_hashes.push(hash);
             }
-            if table.num_entries() >= k as usize {
+            if table.num_retained() >= k as usize {
                 break;
             }
         }
@@ -649,23 +715,21 @@ mod tests {
         let rebuild_threshold = table.get_capacity();
 
         loop {
-            let hash = table.hash_and_screen(format!("value_{}", i));
+            let hash = table.hash(i);
             i += 1;
-            if hash != 0 {
-                table.try_insert(hash);
+            if table.try_insert(i - 1) {
                 inserted_hashes.push(hash);
             }
-            if table.num_entries() >= rebuild_threshold {
+            if table.num_retained() >= rebuild_threshold {
                 break;
             }
         }
 
         // trigger rebuild
         loop {
-            let hash = table.hash_and_screen(format!("value_{}", i));
+            let hash = table.hash(i);
             i += 1;
-            if hash != 0 {
-                table.try_insert(hash);
+            if table.try_insert(i - 1) {
                 inserted_hashes.push(hash);
                 break;
             }
diff --git a/datasketches/src/theta/mod.rs b/datasketches/src/theta/mod.rs
index 1d33a71..0bb230e 100644
--- a/datasketches/src/theta/mod.rs
+++ b/datasketches/src/theta/mod.rs
@@ -47,3 +47,4 @@ mod sketch;
 pub use self::sketch::CompactThetaSketch;
 pub use self::sketch::ThetaSketch;
 pub use self::sketch::ThetaSketchBuilder;
+pub use self::sketch::ThetaSketchView;
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index a56d3c4..ec26b54 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -48,6 +48,32 @@ use crate::theta::serialization::V2_PREAMBLE_EMPTY;
 use crate::theta::serialization::V2_PREAMBLE_ESTIMATE;
 use crate::theta::serialization::V2_PREAMBLE_PRECISE;
 
+/// Read-only view for Theta sketches.
+///
+/// This trait provides a unified input abstraction for APIs that can accept either
+/// mutable [`ThetaSketch`] or immutable [`CompactThetaSketch`].
+pub trait ThetaSketchView {
+    /// Returns the 16-bit seed hash.
+    fn seed_hash(&self) -> u16;
+
+    /// Returns theta as `u64`.
+    fn theta64(&self) -> u64;
+
+    /// Returns true if this sketch is empty.
+    fn is_empty(&self) -> bool;
+
+    /// Returns an iterator over retained hash values.
+    fn iter<'a>(&'a self) -> impl Iterator<Item = u64> + 'a;
+
+    /// Returns number of retained hash values.
+    fn num_retained(&self) -> usize;
+
+    /// Returns whether retained entries are ordered in ascending order.
+    fn is_ordered(&self) -> bool {
+        false
+    }
+}
+
 /// Mutable theta sketch for building from input data
 #[derive(Debug)]
 pub struct ThetaSketch {
@@ -81,10 +107,7 @@ impl ThetaSketch {
     /// assert!(sketch.estimate() >= 1.0);
     /// ```
     pub fn update<T: Hash>(&mut self, value: T) {
-        let hash = self.table.hash_and_screen(value);
-        if hash != 0 {
-            self.table.try_insert(hash);
-        }
+        self.table.try_insert(value);
     }
 
     /// Update the sketch with a f64 value.
@@ -131,7 +154,7 @@ impl ThetaSketch {
         if self.is_empty() {
             return 0.0;
         }
-        let num_retained = self.table.num_entries() as f64;
+        let num_retained = self.table.num_retained() as f64;
         let theta = self.table.theta() as f64 / MAX_THETA as f64;
         num_retained / theta
     }
@@ -146,6 +169,11 @@ impl ThetaSketch {
         self.table.theta()
     }
 
+    /// Return 16-bit seed hash.
+    pub fn seed_hash(&self) -> u16 {
+        self.table.seed_hash()
+    }
+
     /// Check if sketch is empty
     pub fn is_empty(&self) -> bool {
         self.table.is_empty()
@@ -158,7 +186,7 @@ impl ThetaSketch {
 
     /// Return number of retained entries
     pub fn num_retained(&self) -> usize {
-        self.table.num_entries()
+        self.table.num_retained()
     }
 
     /// Return lg_k
@@ -223,13 +251,7 @@ impl ThetaSketch {
             entries.sort_unstable();
         }
 
-        CompactThetaSketch {
-            entries,
-            theta,
-            seed_hash: self.table.seed_hash(),
-            ordered,
-            empty,
-        }
+        CompactThetaSketch::from_parts(entries, theta, self.table.seed_hash(), ordered, empty)
     }
 
     /// Returns the approximate lower error bound given the specified number of Standard Deviations.
@@ -306,6 +328,28 @@ impl ThetaSketch {
     }
 }
 
+impl ThetaSketchView for ThetaSketch {
+    fn seed_hash(&self) -> u16 {
+        ThetaSketch::seed_hash(self)
+    }
+
+    fn theta64(&self) -> u64 {
+        ThetaSketch::theta64(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        ThetaSketch::is_empty(self)
+    }
+
+    fn iter<'a>(&'a self) -> impl Iterator<Item = u64> + 'a {
+        ThetaSketch::iter(self)
+    }
+
+    fn num_retained(&self) -> usize {
+        ThetaSketch::num_retained(self)
+    }
+}
+
 /// Compact (immutable) theta sketch.
 ///
 /// This is the serialized-friendly form of a theta sketch: a compact array of retained hash values
@@ -320,6 +364,22 @@ pub struct CompactThetaSketch {
 }
 
 impl CompactThetaSketch {
+    pub(crate) fn from_parts(
+        entries: Vec<u64>,
+        theta: u64,
+        seed_hash: u16,
+        ordered: bool,
+        empty: bool,
+    ) -> Self {
+        Self {
+            entries,
+            theta,
+            seed_hash,
+            ordered,
+            empty,
+        }
+    }
+
     /// Returns the cardinality estimate.
     pub fn estimate(&self) -> f64 {
         if self.is_empty() {
@@ -823,6 +883,32 @@ impl CompactThetaSketch {
     }
 }
 
+impl ThetaSketchView for CompactThetaSketch {
+    fn seed_hash(&self) -> u16 {
+        CompactThetaSketch::seed_hash(self)
+    }
+
+    fn theta64(&self) -> u64 {
+        CompactThetaSketch::theta64(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        CompactThetaSketch::is_empty(self)
+    }
+
+    fn iter<'a>(&'a self) -> impl Iterator<Item = u64> + 'a {
+        CompactThetaSketch::iter(self)
+    }
+
+    fn num_retained(&self) -> usize {
+        CompactThetaSketch::num_retained(self)
+    }
+
+    fn is_ordered(&self) -> bool {
+        CompactThetaSketch::is_ordered(self)
+    }
+}
+
 /// Builder for ThetaSketch
 #[derive(Debug)]
 pub struct ThetaSketchBuilder {

From 38440dc60e66ed49988fd7d978a2c430856f6a15 Mon Sep 17 00:00:00 2001
From: zenotme <st810918843@gmail.com>
Date: Fri, 20 Feb 2026 20:25:50 +0800
Subject: [PATCH 2/8] refine code: remove unused code

---
 datasketches/src/theta/hash_table.rs | 49 ----------------------------
 1 file changed, 49 deletions(-)

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index 967e2c5..575a6df 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -343,55 +343,6 @@ impl ThetaHashTable {
         compute_seed_hash(self.hash_seed)
     }
 
-    /// Returns true if the given hash exists in the table.
-    #[allow(dead_code)]
-    pub fn contains_hash(&self, hash: u64) -> bool {
-        if hash == 0 {
-            return false;
-        }
-        let Some(index) = self.find_in_curr_entries(hash) else {
-            return false;
-        };
-        self.entries[index] == hash
-    }
-
-    /// Set empty flag
-    #[allow(dead_code)]
-    pub fn set_empty(&mut self, is_empty: bool) {
-        self.is_empty = is_empty;
-    }
-
-    /// Get the hash seed used by this table.
-    #[allow(dead_code)]
-    pub fn hash_seed(&self) -> u64 {
-        self.hash_seed
-    }
-
-    /// Sets theta value.
-    #[allow(dead_code)]
-    pub fn set_theta(&mut self, theta: u64) {
-        assert!(
-            (1..=MAX_THETA).contains(&theta),
-            "theta must be in [1, {MAX_THETA}], got {theta}"
-        );
-        self.theta = theta;
-    }
-
-    /// Returns minimal lg_size where rebuild-capacity can hold `count`.
-    #[allow(dead_code)]
-    pub fn lg_size_from_count_for_rebuild(count: usize, load_factor: f64) -> u8 {
-        let log2 = |n: usize| {
-            if n == 0 { 0_u8 } else { n.ilog2() as u8 }
-        };
-        let log2_n = log2(count);
-        log2_n
-            + (if count > (((1u128 << ((log2_n as u32) + 1)) as f64) * load_factor) as usize {
-                2
-            } else {
-                1
-            })
-    }
-
     /// Get stride for hash table probing
     fn get_stride(key: u64, lg_size: u8) -> usize {
         (2 * ((key >> (lg_size)) & STRIDE_MASK) + 1) as usize

From d7c81fd58ce99d463d92f1a1ecb08f76d400e7fe Mon Sep 17 00:00:00 2001
From: zenotme <st810918843@gmail.com>
Date: Sun, 22 Feb 2026 11:09:21 +0800
Subject: [PATCH 3/8] feat(theta): support theta intersection set operation

---
 datasketches/src/theta/hash_table.rs          |  50 ++-
 datasketches/src/theta/intersection.rs        | 233 +++++++++++++
 datasketches/src/theta/mod.rs                 |   2 +
 datasketches/tests/theta_intersection_test.rs | 316 ++++++++++++++++++
 4 files changed, 598 insertions(+), 3 deletions(-)
 create mode 100644 datasketches/src/theta/intersection.rs
 create mode 100644 datasketches/tests/theta_intersection_test.rs

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index e8e2919..a5fa3c7 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -83,7 +83,7 @@ impl ThetaHashTable {
     ) -> Self {
         let lg_max_size = lg_nom_size + 1;
         let lg_cur_size = starting_sub_multiple(lg_max_size, MIN_LG_K, resize_factor.lg_value());
-        Self::new_with_state(
+        Self::from_raw_parts(
             lg_cur_size,
             lg_nom_size,
             resize_factor,
@@ -94,12 +94,12 @@ impl ThetaHashTable {
         )
     }
 
-    /// Create a table with explicit state.
+    /// Constructs a table from raw internal state.
     ///
     /// # Panics
     ///
     /// Panics if `lg_cur_size > lg_nom_size + 1`. (`lg_nom_size + 1 == lg_max_size`)
-    pub fn new_with_state(
+    pub fn from_raw_parts(
         lg_cur_size: u8,
         lg_nom_size: u8,
         resize_factor: ResizeFactor,
@@ -343,6 +343,50 @@ impl ThetaHashTable {
         compute_seed_hash(self.hash_seed)
     }
 
+    /// Returns true if the given hash exists in the table.
+    pub fn contains_hash(&self, hash: u64) -> bool {
+        if hash == 0 {
+            return false;
+        }
+        let Some(index) = self.find_in_curr_entries(hash) else {
+            return false;
+        };
+        self.entries[index] == hash
+    }
+
+    /// Set empty flag
+    pub fn set_empty(&mut self, is_empty: bool) {
+        self.is_empty = is_empty;
+    }
+
+    /// Get the hash seed used by this table.
+    pub fn hash_seed(&self) -> u64 {
+        self.hash_seed
+    }
+
+    /// Sets theta value.
+    pub fn set_theta(&mut self, theta: u64) {
+        assert!(
+            (1..=MAX_THETA).contains(&theta),
+            "theta must be in [1, {MAX_THETA}], got {theta}"
+        );
+        self.theta = theta;
+    }
+
+    /// Returns minimal lg_size where rebuild-capacity can hold `count`.
+    pub fn lg_size_from_count_for_rebuild(count: usize, load_factor: f64) -> u8 {
+        let log2 = |n: usize| {
+            if n == 0 { 0_u8 } else { n.ilog2() as u8 }
+        };
+        let log2_n = log2(count);
+        log2_n
+            + (if count > (((1u128 << ((log2_n as u32) + 1)) as f64) * load_factor) as usize {
+                2
+            } else {
+                1
+            })
+    }
+
     /// Get stride for hash table probing
     fn get_stride(key: u64, lg_size: u8) -> usize {
         (2 * ((key >> (lg_size)) & STRIDE_MASK) + 1) as usize
diff --git a/datasketches/src/theta/intersection.rs b/datasketches/src/theta/intersection.rs
new file mode 100644
index 0000000..056803f
--- /dev/null
+++ b/datasketches/src/theta/intersection.rs
@@ -0,0 +1,233 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use crate::common::ResizeFactor;
+use crate::error::Error;
+use crate::hash::DEFAULT_UPDATE_SEED;
+use crate::theta::CompactThetaSketch;
+use crate::theta::ThetaSketchView;
+use crate::theta::hash_table::MAX_THETA;
+use crate::theta::hash_table::REBUILD_THRESHOLD;
+use crate::theta::hash_table::ThetaHashTable;
+
+/// Stateful intersection operator for Theta sketches.
+///
+/// Before the first [`update`](Self::update), the result is undefined; use
+/// [`has_result`](Self::has_result) to check.
+#[derive(Debug)]
+pub struct ThetaIntersection {
+    is_valid: bool,
+    table: ThetaHashTable,
+}
+
+impl ThetaIntersection {
+    /// Creates a new intersection operator for the given `seed`.
+    pub fn new(seed: u64) -> Self {
+        Self {
+            is_valid: false,
+            table: ThetaHashTable::from_raw_parts(
+                0,
+                0,
+                ResizeFactor::X1,
+                1.0,
+                MAX_THETA,
+                seed,
+                false,
+            ),
+        }
+    }
+
+    /// Creates a new intersection operator with the default seed.
+    pub fn new_with_default_seed() -> Self {
+        Self::new(DEFAULT_UPDATE_SEED)
+    }
+
+    /// Updates the intersection with a given sketch.
+    ///
+    /// The intersection can be viewed as starting from the "universe" set,
+    /// and every update can reduce the current set to leave the overlapping
+    /// subset only.
+    pub fn update<S: ThetaSketchView>(&mut self, sketch: &S) -> Result<(), Error> {
+        let new_default_table = |table: &ThetaHashTable| {
+            ThetaHashTable::from_raw_parts(
+                0,
+                0,
+                ResizeFactor::X1,
+                1.0,
+                table.theta(),
+                table.hash_seed(),
+                table.is_empty(),
+            )
+        };
+
+        if self.table.is_empty() {
+            return Ok(());
+        }
+
+        if !sketch.is_empty() && sketch.seed_hash() != self.table.seed_hash() {
+            return Err(Error::invalid_argument(format!(
+                "incompatible seed hash: expected {}, got {}",
+                self.table.seed_hash(),
+                sketch.seed_hash()
+            )));
+        }
+
+        self.table
+            .set_empty(self.table.is_empty() || sketch.is_empty());
+        let theta = if self.table.is_empty() {
+            MAX_THETA
+        } else {
+            self.table.theta().min(sketch.theta64())
+        };
+        self.table.set_theta(theta);
+
+        if self.is_valid && self.table.num_retained() == 0 {
+            return Ok(());
+        }
+
+        if sketch.num_retained() == 0 {
+            self.is_valid = true;
+            self.table = new_default_table(&self.table);
+            return Ok(());
+        }
+
+        // first update, copy or move incoming sketch
+        if !self.is_valid {
+            self.is_valid = true;
+            let lg_size = ThetaHashTable::lg_size_from_count_for_rebuild(
+                sketch.num_retained(),
+                REBUILD_THRESHOLD,
+            );
+            self.table = ThetaHashTable::from_raw_parts(
+                lg_size,
+                lg_size - 1,
+                ResizeFactor::X1,
+                1.0,
+                self.table.theta(),
+                self.table.hash_seed(),
+                self.table.is_empty(),
+            );
+            for hash in sketch.iter() {
+                if !self.table.try_insert_hash(hash) {
+                    return Err(Error::invalid_argument(
+                        "Insert entires from sketch fail, possibly corrupted input sketch",
+                    ));
+                }
+            }
+            // Safety check.
+            if self.table.num_retained() != sketch.num_retained() {
+                return Err(Error::invalid_argument(
+                    "num entries mismatch, possibly corrupted input sketch",
+                ));
+            }
+        } else {
+            let max_matches = self.table.num_retained().min(sketch.num_retained());
+            let mut matched_entries = Vec::with_capacity(max_matches);
+            let mut count = 0;
+            for hash in sketch.iter() {
+                if hash < self.table.theta() {
+                    if self.table.contains_hash(hash) {
+                        if matched_entries.len() == max_matches {
+                            return Err(Error::invalid_argument(
+                                "max matches exceeded, possibly corrupted input sketch",
+                            ));
+                        }
+                        matched_entries.push(hash);
+                    }
+                } else if sketch.is_ordered() {
+                    break; // early stop for ordered sketches
+                }
+                count += 1;
+            }
+            // Safety check.
+            if count > sketch.num_retained() {
+                return Err(Error::invalid_argument(
+                    "more keys than expected, possibly corrupted input sketch",
+                ));
+            } else if !sketch.is_ordered() && count < sketch.num_retained() {
+                return Err(Error::invalid_argument(
+                    "fewer keys than expected, possibly corrupted input sketch",
+                ));
+            }
+            if matched_entries.is_empty() {
+                self.table = new_default_table(&self.table);
+                if self.table.theta() == MAX_THETA {
+                    self.table.set_empty(true);
+                }
+            } else {
+                let lg_size = ThetaHashTable::lg_size_from_count_for_rebuild(
+                    matched_entries.len(),
+                    REBUILD_THRESHOLD,
+                );
+                self.table = ThetaHashTable::from_raw_parts(
+                    lg_size,
+                    lg_size - 1,
+                    ResizeFactor::X1,
+                    1.0,
+                    self.table.theta(),
+                    self.table.hash_seed(),
+                    self.table.is_empty(),
+                );
+                for hash in matched_entries {
+                    if !self.table.try_insert_hash(hash) {
+                        return Err(Error::invalid_argument(
+                            "duplicate key, possibly corrupted input sketch",
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Returns whether this operator has received at least one update.
+    pub fn has_result(&self) -> bool {
+        self.is_valid
+    }
+
+    /// Returns the intersection result as a compact theta sketch (ordered).
+    ///
+    /// # Panics
+    ///
+    /// Panics if called before the first [`update`](Self::update).
+    pub fn result(&self) -> CompactThetaSketch {
+        self.result_with_ordered(true)
+    }
+
+    /// Returns the intersection result as a compact theta sketch.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called before the first [`update`](Self::update).
+    pub fn result_with_ordered(&self, ordered: bool) -> CompactThetaSketch {
+        assert!(
+            self.is_valid,
+            "ThetaIntersection::result() called before first update()"
+        );
+        let mut hashes: Vec<u64> = self.table.iter().collect();
+        if ordered {
+            hashes.sort_unstable();
+        }
+        CompactThetaSketch::from_parts(
+            hashes,
+            self.table.theta(),
+            self.table.seed_hash(),
+            ordered,
+            self.table.is_empty(),
+        )
+    }
+}
diff --git a/datasketches/src/theta/mod.rs b/datasketches/src/theta/mod.rs
index 0c1e572..84accc5 100644
--- a/datasketches/src/theta/mod.rs
+++ b/datasketches/src/theta/mod.rs
@@ -41,9 +41,11 @@
 
 mod bit_pack;
 mod hash_table;
+mod intersection;
 mod serialization;
 mod sketch;
 
+pub use self::intersection::ThetaIntersection;
 pub use self::sketch::CompactThetaSketch;
 pub use self::sketch::ThetaSketch;
 pub use self::sketch::ThetaSketchBuilder;
diff --git a/datasketches/tests/theta_intersection_test.rs b/datasketches/tests/theta_intersection_test.rs
new file mode 100644
index 0000000..4959529
--- /dev/null
+++ b/datasketches/tests/theta_intersection_test.rs
@@ -0,0 +1,316 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use datasketches::theta::CompactThetaSketch;
+use datasketches::theta::ThetaIntersection;
+use datasketches::theta::ThetaSketch;
+
+fn sketch_with_range(start: u64, count: u64) -> ThetaSketch {
+    let mut sketch = ThetaSketch::builder().build();
+    for i in 0..count {
+        sketch.update(start + i);
+    }
+    sketch
+}
+
+#[test]
+fn test_has_result_state_machine() {
+    let mut a = ThetaSketch::builder().build();
+    a.update("x");
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    assert!(!i.has_result());
+    i.update(&a).unwrap();
+    assert!(i.has_result());
+    assert!(i.result().estimate() >= 1.0);
+}
+
+#[test]
+fn test_result_before_update_panics() {
+    let i = ThetaIntersection::new(123);
+    let result = std::panic::catch_unwind(|| {
+        let _ = i.result();
+    });
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_update_accepts_compact_sketch() {
+    let mut a = ThetaSketch::builder().build();
+    a.update("x");
+    a.update("y");
+
+    let mut b = ThetaSketch::builder().build();
+    b.update("y");
+    b.update("z");
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&a.compact(true)).unwrap();
+    i.update(&b).unwrap();
+
+    let r = i.result();
+    assert!(r.estimate() == 1.0);
+    assert!(r.is_ordered());
+
+    let mut c = ThetaSketch::builder().build();
+    c.update("a");
+    c.update("b");
+    c.update("c");
+
+    i.update(&c.compact(false)).unwrap();
+
+    let r = i.result_with_ordered(false);
+    assert!(r.estimate() == 0.0);
+    assert!(!r.is_ordered());
+}
+
+#[test]
+fn test_seed_mismatch_behaviour_for_empty_sketch() {
+    let empty_other_seed = ThetaSketch::builder().seed(2).build();
+    let mut i = ThetaIntersection::new(1);
+
+    i.update(&empty_other_seed).unwrap();
+    assert!(i.has_result());
+    let r = i.result();
+    assert!(r.is_empty());
+}
+
+#[test]
+fn test_seed_mismatch_behaviour() {
+    let mut one_other_seed = ThetaSketch::builder().seed(2).build();
+    one_other_seed.update("value");
+    let mut i = ThetaIntersection::new(1);
+
+    assert!(i.update(&one_other_seed).is_err());
+}
+
+#[test]
+fn test_terminal_empty_state_ignores_future_updates() {
+    let empty = ThetaSketch::builder().build();
+
+    let mut non_empty = ThetaSketch::builder().build();
+    non_empty.update("x");
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&empty).unwrap();
+    i.update(&non_empty).unwrap();
+
+    let r = i.result();
+    assert!(r.is_empty());
+}
+
+#[test]
+fn test_result_with_ordered_false_is_not_ordered() {
+    let mut a = ThetaSketch::builder().build();
+    for i in 0..64 {
+        a.update(i);
+    }
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&a).unwrap();
+
+    let r = i.result_with_ordered(false);
+    assert!(!r.is_ordered());
+}
+
+#[test]
+fn test_empty_update_twice() {
+    let empty = ThetaSketch::builder().build();
+    let mut i = ThetaIntersection::new_with_default_seed();
+
+    i.update(&empty).unwrap();
+    let r1 = i.result();
+    assert_eq!(r1.num_retained(), 0);
+    assert!(r1.is_empty());
+    assert!(!r1.is_estimation_mode());
+    assert_eq!(r1.estimate(), 0.0);
+
+    i.update(&empty).unwrap();
+    let r2 = i.result();
+    assert_eq!(r2.num_retained(), 0);
+    assert!(r2.is_empty());
+    assert!(!r2.is_estimation_mode());
+    assert_eq!(r2.estimate(), 0.0);
+}
+
+#[test]
+fn test_non_empty_no_retained_keys() {
+    let mut s = ThetaSketch::builder().sampling_probability(0.001).build();
+    s.update(1u64);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s).unwrap();
+    let r1 = i.result();
+    assert_eq!(r1.num_retained(), 0);
+    assert!(!r1.is_empty());
+    assert!(r1.is_estimation_mode());
+    assert!((r1.theta() - 0.001).abs() < 1e-10);
+    assert_eq!(r1.estimate(), 0.0);
+
+    i.update(&s).unwrap();
+    let r2 = i.result();
+    assert_eq!(r2.num_retained(), 0);
+    assert!(!r2.is_empty());
+    assert!(r2.is_estimation_mode());
+    assert!((r2.theta() - 0.001).abs() < 1e-10);
+    assert_eq!(r2.estimate(), 0.0);
+}
+
+#[test]
+fn test_exact_half_overlap_unordered() {
+    let s1 = sketch_with_range(0, 1000);
+    let s2 = sketch_with_range(500, 1000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1).unwrap();
+    i.update(&s2).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(!r.is_estimation_mode());
+    assert_eq!(r.estimate(), 500.0);
+}
+
+#[test]
+fn test_exact_half_overlap_ordered() {
+    let s1 = sketch_with_range(0, 1000);
+    let s2 = sketch_with_range(500, 1000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1.compact(true)).unwrap();
+    i.update(&s2.compact(true)).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(!r.is_estimation_mode());
+    assert_eq!(r.estimate(), 500.0);
+}
+
+#[test]
+fn test_exact_disjoint_unordered() {
+    let s1 = sketch_with_range(0, 1000);
+    let s2 = sketch_with_range(1000, 1000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1).unwrap();
+    i.update(&s2).unwrap();
+    let r = i.result();
+
+    assert!(r.is_empty());
+    assert!(!r.is_estimation_mode());
+    assert_eq!(r.estimate(), 0.0);
+}
+
+#[test]
+fn test_exact_disjoint_ordered() {
+    let s1 = sketch_with_range(0, 1000);
+    let s2 = sketch_with_range(1000, 1000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1.compact(true)).unwrap();
+    i.update(&s2.compact(true)).unwrap();
+    let r = i.result();
+
+    assert!(r.is_empty());
+    assert!(!r.is_estimation_mode());
+    assert_eq!(r.estimate(), 0.0);
+}
+
+#[test]
+fn test_estimation_half_overlap_unordered() {
+    let s1 = sketch_with_range(0, 10000);
+    let s2 = sketch_with_range(5000, 10000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1).unwrap();
+    i.update(&s2).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(r.is_estimation_mode());
+    assert!((r.estimate() - 5000.0).abs() <= 5000.0 * 0.02);
+}
+
+#[test]
+fn test_estimation_half_overlap_ordered() {
+    let s1 = sketch_with_range(0, 10000);
+    let s2 = sketch_with_range(5000, 10000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1.compact(true)).unwrap();
+    i.update(&s2.compact(true)).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(r.is_estimation_mode());
+    assert!((r.estimate() - 5000.0).abs() <= 5000.0 * 0.02);
+}
+
+#[test]
+fn test_estimation_half_overlap_ordered_deserialized_compact() {
+    let s1 = sketch_with_range(0, 10000);
+    let s2 = sketch_with_range(5000, 10000);
+    let c1 = CompactThetaSketch::deserialize(&s1.compact(true).serialize()).unwrap();
+    let c2 = CompactThetaSketch::deserialize(&s2.compact(true).serialize()).unwrap();
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&c1).unwrap();
+    i.update(&c2).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(r.is_estimation_mode());
+    assert!((r.estimate() - 5000.0).abs() <= 5000.0 * 0.02);
+}
+
+#[test]
+fn test_estimation_disjoint_unordered() {
+    let s1 = sketch_with_range(0, 10000);
+    let s2 = sketch_with_range(10000, 10000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1).unwrap();
+    i.update(&s2).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(r.is_estimation_mode());
+    assert_eq!(r.estimate(), 0.0);
+}
+
+#[test]
+fn test_estimation_disjoint_ordered() {
+    let s1 = sketch_with_range(0, 10000);
+    let s2 = sketch_with_range(10000, 10000);
+
+    let mut i = ThetaIntersection::new_with_default_seed();
+    i.update(&s1.compact(true)).unwrap();
+    i.update(&s2.compact(true)).unwrap();
+    let r = i.result();
+
+    assert!(!r.is_empty());
+    assert!(r.is_estimation_mode());
+    assert_eq!(r.estimate(), 0.0);
+}
+
+#[test]
+fn test_seed_mismatch_non_empty_returns_error() {
+    let mut s = ThetaSketch::builder().build();
+    s.update(1u64);
+
+    let mut i = ThetaIntersection::new(123);
+    assert!(i.update(&s).is_err());
+}

From c3098c6ed28c531fcdbdd47c29d85bc37e88538d Mon Sep 17 00:00:00 2001
From: zenotme <st810918843@gmail.com>
Date: Wed, 25 Feb 2026 09:28:45 +0800
Subject: [PATCH 4/8] fix lint

---
 datasketches/src/theta/intersection.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datasketches/src/theta/intersection.rs b/datasketches/src/theta/intersection.rs
index 056803f..1c6d5d6 100644
--- a/datasketches/src/theta/intersection.rs
+++ b/datasketches/src/theta/intersection.rs
@@ -124,7 +124,7 @@ impl ThetaIntersection {
             for hash in sketch.iter() {
                 if !self.table.try_insert_hash(hash) {
                     return Err(Error::invalid_argument(
-                        "Insert entires from sketch fail, possibly corrupted input sketch",
+                        "Insert entries from sketch fail, possibly corrupted input sketch",
                     ));
                 }
             }

From baeffc76ddd294a2dc924cd8c0ac6f7e26fc7806 Mon Sep 17 00:00:00 2001
From: tison <wander4096@gmail.com>
Date: Tue, 17 Mar 2026 08:16:10 +0800
Subject: [PATCH 5/8] human loop code tidy

Signed-off-by: tison <wander4096@gmail.com>
---
 datasketches/src/theta/hash_table.rs   | 26 ++++++--------------------
 datasketches/src/theta/intersection.rs | 10 +++++-----
 datasketches/src/theta/mod.rs          | 13 +++++++++++++
 datasketches/src/theta/sketch.rs       |  8 ++++----
 4 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index a5fa3c7..ede0788 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -20,24 +20,10 @@ use std::hash::Hash;
 use crate::common::ResizeFactor;
 use crate::hash::MurmurHash3X64128;
 use crate::hash::compute_seed_hash;
-
-/// Maximum theta value (signed max for compatibility with Java)
-pub const MAX_THETA: u64 = i64::MAX as u64;
-
-/// Minimum log2 of K
-pub const MIN_LG_K: u8 = 5;
-
-/// Maximum log2 of K
-pub const MAX_LG_K: u8 = 26;
-
-/// Default log2 of K
-pub const DEFAULT_LG_K: u8 = 12;
-
-/// Resize threshold (0.5 = 50% load factor)
-const RESIZE_THRESHOLD: f64 = 0.5;
-
-/// Rebuild threshold (15/16 = 93.75% load factor)
-pub(crate) const REBUILD_THRESHOLD: f64 = 15.0 / 16.0;
+use crate::theta::HASH_TABLE_REBUILD_THRESHOLD;
+use crate::theta::HASH_TABLE_RESIZE_THRESHOLD;
+use crate::theta::MAX_THETA;
+use crate::theta::MIN_LG_K;
 
 /// Stride hash bits (7 bits for stride calculation)
 const STRIDE_HASH_BITS: u8 = 7;
@@ -220,9 +206,9 @@ impl ThetaHashTable {
     /// Get capacity threshold
     fn get_capacity(&self) -> usize {
         let fraction = if self.lg_cur_size <= self.lg_nom_size {
-            RESIZE_THRESHOLD
+            HASH_TABLE_RESIZE_THRESHOLD
         } else {
-            REBUILD_THRESHOLD
+            HASH_TABLE_REBUILD_THRESHOLD
         };
         (fraction * self.entries.len() as f64) as usize
     }
diff --git a/datasketches/src/theta/intersection.rs b/datasketches/src/theta/intersection.rs
index 1c6d5d6..145fdb7 100644
--- a/datasketches/src/theta/intersection.rs
+++ b/datasketches/src/theta/intersection.rs
@@ -19,9 +19,9 @@ use crate::common::ResizeFactor;
 use crate::error::Error;
 use crate::hash::DEFAULT_UPDATE_SEED;
 use crate::theta::CompactThetaSketch;
+use crate::theta::HASH_TABLE_REBUILD_THRESHOLD;
+use crate::theta::MAX_THETA;
 use crate::theta::ThetaSketchView;
-use crate::theta::hash_table::MAX_THETA;
-use crate::theta::hash_table::REBUILD_THRESHOLD;
 use crate::theta::hash_table::ThetaHashTable;
 
 /// Stateful intersection operator for Theta sketches.
@@ -110,7 +110,7 @@ impl ThetaIntersection {
             self.is_valid = true;
             let lg_size = ThetaHashTable::lg_size_from_count_for_rebuild(
                 sketch.num_retained(),
-                REBUILD_THRESHOLD,
+                HASH_TABLE_REBUILD_THRESHOLD,
             );
             self.table = ThetaHashTable::from_raw_parts(
                 lg_size,
@@ -171,7 +171,7 @@ impl ThetaIntersection {
             } else {
                 let lg_size = ThetaHashTable::lg_size_from_count_for_rebuild(
                     matched_entries.len(),
-                    REBUILD_THRESHOLD,
+                    HASH_TABLE_REBUILD_THRESHOLD,
                 );
                 self.table = ThetaHashTable::from_raw_parts(
                     lg_size,
@@ -218,7 +218,7 @@ impl ThetaIntersection {
             self.is_valid,
             "ThetaIntersection::result() called before first update()"
         );
-        let mut hashes: Vec<u64> = self.table.iter().collect();
+        let mut hashes = self.table.iter().collect::<Vec<_>>();
         if ordered {
             hashes.sort_unstable();
         }
diff --git a/datasketches/src/theta/mod.rs b/datasketches/src/theta/mod.rs
index 84accc5..03b5e2a 100644
--- a/datasketches/src/theta/mod.rs
+++ b/datasketches/src/theta/mod.rs
@@ -50,3 +50,16 @@ pub use self::sketch::CompactThetaSketch;
 pub use self::sketch::ThetaSketch;
 pub use self::sketch::ThetaSketchBuilder;
 pub use self::sketch::ThetaSketchView;
+
+/// Maximum theta value (signed max for compatibility with Java)
+const MAX_THETA: u64 = i64::MAX as u64;
+/// Minimum log2 of K
+const MIN_LG_K: u8 = 5;
+/// Maximum log2 of K
+const MAX_LG_K: u8 = 26;
+/// Default log2 of K
+const DEFAULT_LG_K: u8 = 12;
+/// Resize threshold (0.5 = 50% load factor)
+const HASH_TABLE_RESIZE_THRESHOLD: f64 = 0.5;
+/// Rebuild threshold (15/16 = 93.75% load factor)
+const HASH_TABLE_REBUILD_THRESHOLD: f64 = 15.0 / 16.0;
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index eeea6c1..d38e43b 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -34,15 +34,15 @@ use crate::common::canonical_double;
 use crate::error::Error;
 use crate::hash::DEFAULT_UPDATE_SEED;
 use crate::hash::compute_seed_hash;
+use crate::theta::DEFAULT_LG_K;
+use crate::theta::MAX_LG_K;
+use crate::theta::MAX_THETA;
+use crate::theta::MIN_LG_K;
 use crate::theta::bit_pack::BLOCK_WIDTH;
 use crate::theta::bit_pack::BitPacker;
 use crate::theta::bit_pack::BitUnpacker;
 use crate::theta::bit_pack::pack_bits_block;
 use crate::theta::bit_pack::unpack_bits_block;
-use crate::theta::hash_table::DEFAULT_LG_K;
-use crate::theta::hash_table::MAX_LG_K;
-use crate::theta::hash_table::MAX_THETA;
-use crate::theta::hash_table::MIN_LG_K;
 use crate::theta::hash_table::ThetaHashTable;
 use crate::theta::serialization;
 use crate::theta::serialization::V2_PREAMBLE_EMPTY;

From 5cd55b963d38953794ec9f804fe3af0b8392dc7e Mon Sep 17 00:00:00 2001
From: tison <wander4096@gmail.com>
Date: Tue, 17 Mar 2026 08:19:01 +0800
Subject: [PATCH 6/8] code format

Signed-off-by: tison <wander4096@gmail.com>
---
 datasketches/src/theta/bit_pack.rs      | 3316 +++++++++++------------
 datasketches/src/theta/hash_table.rs    |    2 +-
 datasketches/src/theta/serialization.rs |   18 +-
 datasketches/src/theta/sketch.rs        |    2 +-
 4 files changed, 1664 insertions(+), 1674 deletions(-)

diff --git a/datasketches/src/theta/bit_pack.rs b/datasketches/src/theta/bit_pack.rs
index 013899b..0c8902f 100644
--- a/datasketches/src/theta/bit_pack.rs
+++ b/datasketches/src/theta/bit_pack.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub(crate) const BLOCK_WIDTH: usize = 8;
+pub(super) const BLOCK_WIDTH: usize = 8;
 
 #[inline]
 fn low_bit_to_byte_mask(bits: u8) -> u8 {
@@ -33,7 +33,7 @@ fn low_bit_to_byte_mask(bits: u8) -> u8 {
 /// Panics if the buffer is too small to hold the packed values.
 /// The caller must ensure that `bytes` has enough capacity for
 /// the total number of bits to be packed.
-pub(crate) struct BitPacker<'a> {
+pub(super) struct BitPacker<'a> {
     bytes: &'a mut [u8],
     byte_index: usize,
     byte_bit_used: u8,
@@ -104,7 +104,7 @@ impl<'a> BitPacker<'a> {
 /// Panics if the buffer is too small to provide the requested bits.
 /// The caller must ensure that `bytes` has enough capacity for
 /// the total number of bits to be unpacked.
-pub(crate) struct BitUnpacker<'a> {
+pub(super) struct BitUnpacker<'a> {
     bytes: &'a [u8],
     byte_index: usize,
     byte_bit_used: u8,
@@ -2531,2441 +2531,2431 @@ fn unpack_bits_7(values: &mut [u64], bytes: &[u8]) {
 
 #[inline]
 fn unpack_bits_8(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (bytes[0]) as u64;
-    values[1] = (bytes[1]) as u64;
-    values[2] = (bytes[2]) as u64;
-    values[3] = (bytes[3]) as u64;
-    values[4] = (bytes[4]) as u64;
-    values[5] = (bytes[5]) as u64;
-    values[6] = (bytes[6]) as u64;
-    values[7] = (bytes[7]) as u64;
+    values[0] = bytes[0] as u64;
+    values[1] = bytes[1] as u64;
+    values[2] = bytes[2] as u64;
+    values[3] = bytes[3] as u64;
+    values[4] = bytes[4] as u64;
+    values[5] = bytes[5] as u64;
+    values[6] = bytes[6] as u64;
+    values[7] = bytes[7] as u64;
 }
 
 #[inline]
 fn unpack_bits_9(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 1) | (((bytes[1] >> 7) & 0x1) as u64);
+    values[0] = ((bytes[0] as u64) << 1) | (((bytes[1] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[1]) & 0x7f) as u64) << 2) | (((bytes[2] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[2]) & 0x3f) as u64) << 3) | (((bytes[3] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[3]) & 0x1f) as u64) << 4) | (((bytes[4] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[4]) & 0xf) as u64) << 5) | (((bytes[5] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[5]) & 0x7) as u64) << 6) | (((bytes[6] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[6]) & 0x3) as u64) << 7) | (((bytes[7] >> 1) & 0x7f) as u64);
-    values[7] = ((((bytes[7]) & 0x1) as u64) << 8) | ((bytes[8]) as u64);
+    values[7] = ((((bytes[7]) & 0x1) as u64) << 8) | (bytes[8] as u64);
 }
 
 #[inline]
 fn unpack_bits_10(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 2) | (((bytes[1] >> 6) & 0x3) as u64);
+    values[0] = ((bytes[0] as u64) << 2) | (((bytes[1] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[1]) & 0x3f) as u64) << 4) | (((bytes[2] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[2]) & 0xf) as u64) << 6) | (((bytes[3] >> 2) & 0x3f) as u64);
-    values[3] = ((((bytes[3]) & 0x3) as u64) << 8) | ((bytes[4]) as u64);
-    values[4] = (((bytes[5]) as u64) << 2) | (((bytes[6] >> 6) & 0x3) as u64);
+    values[3] = ((((bytes[3]) & 0x3) as u64) << 8) | (bytes[4] as u64);
+    values[4] = ((bytes[5] as u64) << 2) | (((bytes[6] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[6]) & 0x3f) as u64) << 4) | (((bytes[7] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[7]) & 0xf) as u64) << 6) | (((bytes[8] >> 2) & 0x3f) as u64);
-    values[7] = ((((bytes[8]) & 0x3) as u64) << 8) | ((bytes[9]) as u64);
+    values[7] = ((((bytes[8]) & 0x3) as u64) << 8) | (bytes[9] as u64);
 }
 
 #[inline]
 fn unpack_bits_11(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 3) | (((bytes[1] >> 5) & 0x7) as u64);
+    values[0] = ((bytes[0] as u64) << 3) | (((bytes[1] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[1]) & 0x1f) as u64) << 6) | (((bytes[2] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[2]) & 0x3) as u64) << 9)
-        | (((bytes[3]) as u64) << 1)
+        | ((bytes[3] as u64) << 1)
         | (((bytes[4] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[4]) & 0x7f) as u64) << 4) | (((bytes[5] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[5]) & 0xf) as u64) << 7) | (((bytes[6] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[6]) & 0x1) as u64) << 10)
-        | (((bytes[7]) as u64) << 2)
+        | ((bytes[7] as u64) << 2)
         | (((bytes[8] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[8]) & 0x3f) as u64) << 5) | (((bytes[9] >> 3) & 0x1f) as u64);
-    values[7] = ((((bytes[9]) & 0x7) as u64) << 8) | ((bytes[10]) as u64);
+    values[7] = ((((bytes[9]) & 0x7) as u64) << 8) | (bytes[10] as u64);
 }
 
 #[inline]
 fn unpack_bits_12(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 4) | (((bytes[1] >> 4) & 0xf) as u64);
-    values[1] = ((((bytes[1]) & 0xf) as u64) << 8) | ((bytes[2]) as u64);
-    values[2] = (((bytes[3]) as u64) << 4) | (((bytes[4] >> 4) & 0xf) as u64);
-    values[3] = ((((bytes[4]) & 0xf) as u64) << 8) | ((bytes[5]) as u64);
-    values[4] = (((bytes[6]) as u64) << 4) | (((bytes[7] >> 4) & 0xf) as u64);
-    values[5] = ((((bytes[7]) & 0xf) as u64) << 8) | ((bytes[8]) as u64);
-    values[6] = (((bytes[9]) as u64) << 4) | (((bytes[10] >> 4) & 0xf) as u64);
-    values[7] = ((((bytes[10]) & 0xf) as u64) << 8) | ((bytes[11]) as u64);
+    values[0] = ((bytes[0] as u64) << 4) | (((bytes[1] >> 4) & 0xf) as u64);
+    values[1] = ((((bytes[1]) & 0xf) as u64) << 8) | (bytes[2] as u64);
+    values[2] = ((bytes[3] as u64) << 4) | (((bytes[4] >> 4) & 0xf) as u64);
+    values[3] = ((((bytes[4]) & 0xf) as u64) << 8) | (bytes[5] as u64);
+    values[4] = ((bytes[6] as u64) << 4) | (((bytes[7] >> 4) & 0xf) as u64);
+    values[5] = ((((bytes[7]) & 0xf) as u64) << 8) | (bytes[8] as u64);
+    values[6] = ((bytes[9] as u64) << 4) | (((bytes[10] >> 4) & 0xf) as u64);
+    values[7] = ((((bytes[10]) & 0xf) as u64) << 8) | (bytes[11] as u64);
 }
 
 #[inline]
 fn unpack_bits_13(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 5) | (((bytes[1] >> 3) & 0x1f) as u64);
+    values[0] = ((bytes[0] as u64) << 5) | (((bytes[1] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[1]) & 0x7) as u64) << 10)
-        | (((bytes[2]) as u64) << 2)
+        | ((bytes[2] as u64) << 2)
         | (((bytes[3] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[3]) & 0x3f) as u64) << 7) | (((bytes[4] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[4]) & 0x1) as u64) << 12)
-        | (((bytes[5]) as u64) << 4)
+        | ((bytes[5] as u64) << 4)
         | (((bytes[6] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[6]) & 0xf) as u64) << 9)
-        | (((bytes[7]) as u64) << 1)
+        | ((bytes[7] as u64) << 1)
         | (((bytes[8] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[8]) & 0x7f) as u64) << 6) | (((bytes[9] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[9]) & 0x3) as u64) << 11)
-        | (((bytes[10]) as u64) << 3)
+        | ((bytes[10] as u64) << 3)
         | (((bytes[11] >> 5) & 0x7) as u64);
-    values[7] = ((((bytes[11]) & 0x1f) as u64) << 8) | ((bytes[12]) as u64);
+    values[7] = ((((bytes[11]) & 0x1f) as u64) << 8) | (bytes[12] as u64);
 }
 
 #[inline]
 fn unpack_bits_14(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 6) | (((bytes[1] >> 2) & 0x3f) as u64);
+    values[0] = ((bytes[0] as u64) << 6) | (((bytes[1] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[1]) & 0x3) as u64) << 12)
-        | (((bytes[2]) as u64) << 4)
+        | ((bytes[2] as u64) << 4)
         | (((bytes[3] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[3]) & 0xf) as u64) << 10)
-        | (((bytes[4]) as u64) << 2)
+        | ((bytes[4] as u64) << 2)
         | (((bytes[5] >> 6) & 0x3) as u64);
-    values[3] = ((((bytes[5]) & 0x3f) as u64) << 8) | ((bytes[6]) as u64);
-    values[4] = (((bytes[7]) as u64) << 6) | (((bytes[8] >> 2) & 0x3f) as u64);
+    values[3] = ((((bytes[5]) & 0x3f) as u64) << 8) | (bytes[6] as u64);
+    values[4] = ((bytes[7] as u64) << 6) | (((bytes[8] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[8]) & 0x3) as u64) << 12)
-        | (((bytes[9]) as u64) << 4)
+        | ((bytes[9] as u64) << 4)
         | (((bytes[10] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[10]) & 0xf) as u64) << 10)
-        | (((bytes[11]) as u64) << 2)
+        | ((bytes[11] as u64) << 2)
         | (((bytes[12] >> 6) & 0x3) as u64);
-    values[7] = ((((bytes[12]) & 0x3f) as u64) << 8) | ((bytes[13]) as u64);
+    values[7] = ((((bytes[12]) & 0x3f) as u64) << 8) | (bytes[13] as u64);
 }
 
 #[inline]
 fn unpack_bits_15(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 7) | (((bytes[1] >> 1) & 0x7f) as u64);
+    values[0] = ((bytes[0] as u64) << 7) | (((bytes[1] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[1]) & 0x1) as u64) << 14)
-        | (((bytes[2]) as u64) << 6)
+        | ((bytes[2] as u64) << 6)
         | (((bytes[3] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[3]) & 0x3) as u64) << 13)
-        | (((bytes[4]) as u64) << 5)
+        | ((bytes[4] as u64) << 5)
         | (((bytes[5] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[5]) & 0x7) as u64) << 12)
-        | (((bytes[6]) as u64) << 4)
+        | ((bytes[6] as u64) << 4)
         | (((bytes[7] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[7]) & 0xf) as u64) << 11)
-        | (((bytes[8]) as u64) << 3)
+        | ((bytes[8] as u64) << 3)
         | (((bytes[9] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[9]) & 0x1f) as u64) << 10)
-        | (((bytes[10]) as u64) << 2)
+        | ((bytes[10] as u64) << 2)
         | (((bytes[11] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[11]) & 0x3f) as u64) << 9)
-        | (((bytes[12]) as u64) << 1)
+        | ((bytes[12] as u64) << 1)
         | (((bytes[13] >> 7) & 0x1) as u64);
-    values[7] = ((((bytes[13]) & 0x7f) as u64) << 8) | ((bytes[14]) as u64);
+    values[7] = ((((bytes[13]) & 0x7f) as u64) << 8) | (bytes[14] as u64);
 }
 
 #[inline]
 fn unpack_bits_16(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 8) | ((bytes[1]) as u64);
-    values[1] = (((bytes[2]) as u64) << 8) | ((bytes[3]) as u64);
-    values[2] = (((bytes[4]) as u64) << 8) | ((bytes[5]) as u64);
-    values[3] = (((bytes[6]) as u64) << 8) | ((bytes[7]) as u64);
-    values[4] = (((bytes[8]) as u64) << 8) | ((bytes[9]) as u64);
-    values[5] = (((bytes[10]) as u64) << 8) | ((bytes[11]) as u64);
-    values[6] = (((bytes[12]) as u64) << 8) | ((bytes[13]) as u64);
-    values[7] = (((bytes[14]) as u64) << 8) | ((bytes[15]) as u64);
+    values[0] = ((bytes[0] as u64) << 8) | (bytes[1] as u64);
+    values[1] = ((bytes[2] as u64) << 8) | (bytes[3] as u64);
+    values[2] = ((bytes[4] as u64) << 8) | (bytes[5] as u64);
+    values[3] = ((bytes[6] as u64) << 8) | (bytes[7] as u64);
+    values[4] = ((bytes[8] as u64) << 8) | (bytes[9] as u64);
+    values[5] = ((bytes[10] as u64) << 8) | (bytes[11] as u64);
+    values[6] = ((bytes[12] as u64) << 8) | (bytes[13] as u64);
+    values[7] = ((bytes[14] as u64) << 8) | (bytes[15] as u64);
 }
 
 #[inline]
 fn unpack_bits_17(values: &mut [u64], bytes: &[u8]) {
     values[0] =
-        (((bytes[0]) as u64) << 9) | (((bytes[1]) as u64) << 1) | (((bytes[2] >> 7) & 0x1) as u64);
+        ((bytes[0] as u64) << 9) | ((bytes[1] as u64) << 1) | (((bytes[2] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[2]) & 0x7f) as u64) << 10)
-        | (((bytes[3]) as u64) << 2)
+        | ((bytes[3] as u64) << 2)
         | (((bytes[4] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[4]) & 0x3f) as u64) << 11)
-        | (((bytes[5]) as u64) << 3)
+        | ((bytes[5] as u64) << 3)
         | (((bytes[6] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[6]) & 0x1f) as u64) << 12)
-        | (((bytes[7]) as u64) << 4)
+        | ((bytes[7] as u64) << 4)
         | (((bytes[8] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[8]) & 0xf) as u64) << 13)
-        | (((bytes[9]) as u64) << 5)
+        | ((bytes[9] as u64) << 5)
         | (((bytes[10] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[10]) & 0x7) as u64) << 14)
-        | (((bytes[11]) as u64) << 6)
+        | ((bytes[11] as u64) << 6)
         | (((bytes[12] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[12]) & 0x3) as u64) << 15)
-        | (((bytes[13]) as u64) << 7)
+        | ((bytes[13] as u64) << 7)
         | (((bytes[14] >> 1) & 0x7f) as u64);
     values[7] =
-        ((((bytes[14]) & 0x1) as u64) << 16) | (((bytes[15]) as u64) << 8) | ((bytes[16]) as u64);
+        ((((bytes[14]) & 0x1) as u64) << 16) | ((bytes[15] as u64) << 8) | (bytes[16] as u64);
 }
 
 #[inline]
 fn unpack_bits_18(values: &mut [u64], bytes: &[u8]) {
     values[0] =
-        (((bytes[0]) as u64) << 10) | (((bytes[1]) as u64) << 2) | (((bytes[2] >> 6) & 0x3) as u64);
+        ((bytes[0] as u64) << 10) | ((bytes[1] as u64) << 2) | (((bytes[2] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[2]) & 0x3f) as u64) << 12)
-        | (((bytes[3]) as u64) << 4)
+        | ((bytes[3] as u64) << 4)
         | (((bytes[4] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[4]) & 0xf) as u64) << 14)
-        | (((bytes[5]) as u64) << 6)
+        | ((bytes[5] as u64) << 6)
         | (((bytes[6] >> 2) & 0x3f) as u64);
-    values[3] =
-        ((((bytes[6]) & 0x3) as u64) << 16) | (((bytes[7]) as u64) << 8) | ((bytes[8]) as u64);
-    values[4] = (((bytes[9]) as u64) << 10)
-        | (((bytes[10]) as u64) << 2)
-        | (((bytes[11] >> 6) & 0x3) as u64);
+    values[3] = ((((bytes[6]) & 0x3) as u64) << 16) | ((bytes[7] as u64) << 8) | (bytes[8] as u64);
+    values[4] =
+        ((bytes[9] as u64) << 10) | ((bytes[10] as u64) << 2) | (((bytes[11] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[11]) & 0x3f) as u64) << 12)
-        | (((bytes[12]) as u64) << 4)
+        | ((bytes[12] as u64) << 4)
         | (((bytes[13] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[13]) & 0xf) as u64) << 14)
-        | (((bytes[14]) as u64) << 6)
+        | ((bytes[14] as u64) << 6)
         | (((bytes[15] >> 2) & 0x3f) as u64);
     values[7] =
-        ((((bytes[15]) & 0x3) as u64) << 16) | (((bytes[16]) as u64) << 8) | ((bytes[17]) as u64);
+        ((((bytes[15]) & 0x3) as u64) << 16) | ((bytes[16] as u64) << 8) | (bytes[17] as u64);
 }
 
 #[inline]
 fn unpack_bits_19(values: &mut [u64], bytes: &[u8]) {
     values[0] =
-        (((bytes[0]) as u64) << 11) | (((bytes[1]) as u64) << 3) | (((bytes[2] >> 5) & 0x7) as u64);
+        ((bytes[0] as u64) << 11) | ((bytes[1] as u64) << 3) | (((bytes[2] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[2]) & 0x1f) as u64) << 14)
-        | (((bytes[3]) as u64) << 6)
+        | ((bytes[3] as u64) << 6)
         | (((bytes[4] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[4]) & 0x3) as u64) << 17)
-        | (((bytes[5]) as u64) << 9)
-        | (((bytes[6]) as u64) << 1)
+        | ((bytes[5] as u64) << 9)
+        | ((bytes[6] as u64) << 1)
         | (((bytes[7] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[7]) & 0x7f) as u64) << 12)
-        | (((bytes[8]) as u64) << 4)
+        | ((bytes[8] as u64) << 4)
         | (((bytes[9] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[9]) & 0xf) as u64) << 15)
-        | (((bytes[10]) as u64) << 7)
+        | ((bytes[10] as u64) << 7)
         | (((bytes[11] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[11]) & 0x1) as u64) << 18)
-        | (((bytes[12]) as u64) << 10)
-        | (((bytes[13]) as u64) << 2)
+        | ((bytes[12] as u64) << 10)
+        | ((bytes[13] as u64) << 2)
         | (((bytes[14] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[14]) & 0x3f) as u64) << 13)
-        | (((bytes[15]) as u64) << 5)
+        | ((bytes[15] as u64) << 5)
         | (((bytes[16] >> 3) & 0x1f) as u64);
     values[7] =
-        ((((bytes[16]) & 0x7) as u64) << 16) | (((bytes[17]) as u64) << 8) | ((bytes[18]) as u64);
+        ((((bytes[16]) & 0x7) as u64) << 16) | ((bytes[17] as u64) << 8) | (bytes[18] as u64);
 }
 
 #[inline]
 fn unpack_bits_20(values: &mut [u64], bytes: &[u8]) {
     values[0] =
-        (((bytes[0]) as u64) << 12) | (((bytes[1]) as u64) << 4) | (((bytes[2] >> 4) & 0xf) as u64);
-    values[1] =
-        ((((bytes[2]) & 0xf) as u64) << 16) | (((bytes[3]) as u64) << 8) | ((bytes[4]) as u64);
+        ((bytes[0] as u64) << 12) | ((bytes[1] as u64) << 4) | (((bytes[2] >> 4) & 0xf) as u64);
+    values[1] = ((((bytes[2]) & 0xf) as u64) << 16) | ((bytes[3] as u64) << 8) | (bytes[4] as u64);
     values[2] =
-        (((bytes[5]) as u64) << 12) | (((bytes[6]) as u64) << 4) | (((bytes[7] >> 4) & 0xf) as u64);
-    values[3] =
-        ((((bytes[7]) & 0xf) as u64) << 16) | (((bytes[8]) as u64) << 8) | ((bytes[9]) as u64);
-    values[4] = (((bytes[10]) as u64) << 12)
-        | (((bytes[11]) as u64) << 4)
-        | (((bytes[12] >> 4) & 0xf) as u64);
+        ((bytes[5] as u64) << 12) | ((bytes[6] as u64) << 4) | (((bytes[7] >> 4) & 0xf) as u64);
+    values[3] = ((((bytes[7]) & 0xf) as u64) << 16) | ((bytes[8] as u64) << 8) | (bytes[9] as u64);
+    values[4] =
+        ((bytes[10] as u64) << 12) | ((bytes[11] as u64) << 4) | (((bytes[12] >> 4) & 0xf) as u64);
     values[5] =
-        ((((bytes[12]) & 0xf) as u64) << 16) | (((bytes[13]) as u64) << 8) | ((bytes[14]) as u64);
-    values[6] = (((bytes[15]) as u64) << 12)
-        | (((bytes[16]) as u64) << 4)
-        | (((bytes[17] >> 4) & 0xf) as u64);
+        ((((bytes[12]) & 0xf) as u64) << 16) | ((bytes[13] as u64) << 8) | (bytes[14] as u64);
+    values[6] =
+        ((bytes[15] as u64) << 12) | ((bytes[16] as u64) << 4) | (((bytes[17] >> 4) & 0xf) as u64);
     values[7] =
-        ((((bytes[17]) & 0xf) as u64) << 16) | (((bytes[18]) as u64) << 8) | ((bytes[19]) as u64);
+        ((((bytes[17]) & 0xf) as u64) << 16) | ((bytes[18] as u64) << 8) | (bytes[19] as u64);
 }
 
 #[inline]
 fn unpack_bits_21(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 13)
-        | (((bytes[1]) as u64) << 5)
-        | (((bytes[2] >> 3) & 0x1f) as u64);
+    values[0] =
+        ((bytes[0] as u64) << 13) | ((bytes[1] as u64) << 5) | (((bytes[2] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[2]) & 0x7) as u64) << 18)
-        | (((bytes[3]) as u64) << 10)
-        | (((bytes[4]) as u64) << 2)
+        | ((bytes[3] as u64) << 10)
+        | ((bytes[4] as u64) << 2)
         | (((bytes[5] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[5]) & 0x3f) as u64) << 15)
-        | (((bytes[6]) as u64) << 7)
+        | ((bytes[6] as u64) << 7)
         | (((bytes[7] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[7]) & 0x1) as u64) << 20)
-        | (((bytes[8]) as u64) << 12)
-        | (((bytes[9]) as u64) << 4)
+        | ((bytes[8] as u64) << 12)
+        | ((bytes[9] as u64) << 4)
         | (((bytes[10] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[10]) & 0xf) as u64) << 17)
-        | (((bytes[11]) as u64) << 9)
-        | (((bytes[12]) as u64) << 1)
+        | ((bytes[11] as u64) << 9)
+        | ((bytes[12] as u64) << 1)
         | (((bytes[13] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[13]) & 0x7f) as u64) << 14)
-        | (((bytes[14]) as u64) << 6)
+        | ((bytes[14] as u64) << 6)
         | (((bytes[15] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[15]) & 0x3) as u64) << 19)
-        | (((bytes[16]) as u64) << 11)
-        | (((bytes[17]) as u64) << 3)
+        | ((bytes[16] as u64) << 11)
+        | ((bytes[17] as u64) << 3)
         | (((bytes[18] >> 5) & 0x7) as u64);
     values[7] =
-        ((((bytes[18]) & 0x1f) as u64) << 16) | (((bytes[19]) as u64) << 8) | ((bytes[20]) as u64);
+        ((((bytes[18]) & 0x1f) as u64) << 16) | ((bytes[19] as u64) << 8) | (bytes[20] as u64);
 }
 
 #[inline]
 fn unpack_bits_22(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 14)
-        | (((bytes[1]) as u64) << 6)
-        | (((bytes[2] >> 2) & 0x3f) as u64);
+    values[0] =
+        ((bytes[0] as u64) << 14) | ((bytes[1] as u64) << 6) | (((bytes[2] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[2]) & 0x3) as u64) << 20)
-        | (((bytes[3]) as u64) << 12)
-        | (((bytes[4]) as u64) << 4)
+        | ((bytes[3] as u64) << 12)
+        | ((bytes[4] as u64) << 4)
         | (((bytes[5] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[5]) & 0xf) as u64) << 18)
-        | (((bytes[6]) as u64) << 10)
-        | (((bytes[7]) as u64) << 2)
+        | ((bytes[6] as u64) << 10)
+        | ((bytes[7] as u64) << 2)
         | (((bytes[8] >> 6) & 0x3) as u64);
     values[3] =
-        ((((bytes[8]) & 0x3f) as u64) << 16) | (((bytes[9]) as u64) << 8) | ((bytes[10]) as u64);
-    values[4] = (((bytes[11]) as u64) << 14)
-        | (((bytes[12]) as u64) << 6)
-        | (((bytes[13] >> 2) & 0x3f) as u64);
+        ((((bytes[8]) & 0x3f) as u64) << 16) | ((bytes[9] as u64) << 8) | (bytes[10] as u64);
+    values[4] =
+        ((bytes[11] as u64) << 14) | ((bytes[12] as u64) << 6) | (((bytes[13] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[13]) & 0x3) as u64) << 20)
-        | (((bytes[14]) as u64) << 12)
-        | (((bytes[15]) as u64) << 4)
+        | ((bytes[14] as u64) << 12)
+        | ((bytes[15] as u64) << 4)
         | (((bytes[16] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[16]) & 0xf) as u64) << 18)
-        | (((bytes[17]) as u64) << 10)
-        | (((bytes[18]) as u64) << 2)
+        | ((bytes[17] as u64) << 10)
+        | ((bytes[18] as u64) << 2)
         | (((bytes[19] >> 6) & 0x3) as u64);
     values[7] =
-        ((((bytes[19]) & 0x3f) as u64) << 16) | (((bytes[20]) as u64) << 8) | ((bytes[21]) as u64);
+        ((((bytes[19]) & 0x3f) as u64) << 16) | ((bytes[20] as u64) << 8) | (bytes[21] as u64);
 }
 
 #[inline]
 fn unpack_bits_23(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 15)
-        | (((bytes[1]) as u64) << 7)
-        | (((bytes[2] >> 1) & 0x7f) as u64);
+    values[0] =
+        ((bytes[0] as u64) << 15) | ((bytes[1] as u64) << 7) | (((bytes[2] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[2]) & 0x1) as u64) << 22)
-        | (((bytes[3]) as u64) << 14)
-        | (((bytes[4]) as u64) << 6)
+        | ((bytes[3] as u64) << 14)
+        | ((bytes[4] as u64) << 6)
         | (((bytes[5] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[5]) & 0x3) as u64) << 21)
-        | (((bytes[6]) as u64) << 13)
-        | (((bytes[7]) as u64) << 5)
+        | ((bytes[6] as u64) << 13)
+        | ((bytes[7] as u64) << 5)
         | (((bytes[8] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[8]) & 0x7) as u64) << 20)
-        | (((bytes[9]) as u64) << 12)
-        | (((bytes[10]) as u64) << 4)
+        | ((bytes[9] as u64) << 12)
+        | ((bytes[10] as u64) << 4)
         | (((bytes[11] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[11]) & 0xf) as u64) << 19)
-        | (((bytes[12]) as u64) << 11)
-        | (((bytes[13]) as u64) << 3)
+        | ((bytes[12] as u64) << 11)
+        | ((bytes[13] as u64) << 3)
         | (((bytes[14] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[14]) & 0x1f) as u64) << 18)
-        | (((bytes[15]) as u64) << 10)
-        | (((bytes[16]) as u64) << 2)
+        | ((bytes[15] as u64) << 10)
+        | ((bytes[16] as u64) << 2)
         | (((bytes[17] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[17]) & 0x3f) as u64) << 17)
-        | (((bytes[18]) as u64) << 9)
-        | (((bytes[19]) as u64) << 1)
+        | ((bytes[18] as u64) << 9)
+        | ((bytes[19] as u64) << 1)
         | (((bytes[20] >> 7) & 0x1) as u64);
     values[7] =
-        ((((bytes[20]) & 0x7f) as u64) << 16) | (((bytes[21]) as u64) << 8) | ((bytes[22]) as u64);
+        ((((bytes[20]) & 0x7f) as u64) << 16) | ((bytes[21] as u64) << 8) | (bytes[22] as u64);
 }
 
 #[inline]
 fn unpack_bits_24(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 16) | (((bytes[1]) as u64) << 8) | ((bytes[2]) as u64);
-    values[1] = (((bytes[3]) as u64) << 16) | (((bytes[4]) as u64) << 8) | ((bytes[5]) as u64);
-    values[2] = (((bytes[6]) as u64) << 16) | (((bytes[7]) as u64) << 8) | ((bytes[8]) as u64);
-    values[3] = (((bytes[9]) as u64) << 16) | (((bytes[10]) as u64) << 8) | ((bytes[11]) as u64);
-    values[4] = (((bytes[12]) as u64) << 16) | (((bytes[13]) as u64) << 8) | ((bytes[14]) as u64);
-    values[5] = (((bytes[15]) as u64) << 16) | (((bytes[16]) as u64) << 8) | ((bytes[17]) as u64);
-    values[6] = (((bytes[18]) as u64) << 16) | (((bytes[19]) as u64) << 8) | ((bytes[20]) as u64);
-    values[7] = (((bytes[21]) as u64) << 16) | (((bytes[22]) as u64) << 8) | ((bytes[23]) as u64);
+    values[0] = ((bytes[0] as u64) << 16) | ((bytes[1] as u64) << 8) | (bytes[2] as u64);
+    values[1] = ((bytes[3] as u64) << 16) | ((bytes[4] as u64) << 8) | (bytes[5] as u64);
+    values[2] = ((bytes[6] as u64) << 16) | ((bytes[7] as u64) << 8) | (bytes[8] as u64);
+    values[3] = ((bytes[9] as u64) << 16) | ((bytes[10] as u64) << 8) | (bytes[11] as u64);
+    values[4] = ((bytes[12] as u64) << 16) | ((bytes[13] as u64) << 8) | (bytes[14] as u64);
+    values[5] = ((bytes[15] as u64) << 16) | ((bytes[16] as u64) << 8) | (bytes[17] as u64);
+    values[6] = ((bytes[18] as u64) << 16) | ((bytes[19] as u64) << 8) | (bytes[20] as u64);
+    values[7] = ((bytes[21] as u64) << 16) | ((bytes[22] as u64) << 8) | (bytes[23] as u64);
 }
 
 #[inline]
 fn unpack_bits_25(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 17)
-        | (((bytes[1]) as u64) << 9)
-        | (((bytes[2]) as u64) << 1)
+    values[0] = ((bytes[0] as u64) << 17)
+        | ((bytes[1] as u64) << 9)
+        | ((bytes[2] as u64) << 1)
         | (((bytes[3] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[3]) & 0x7f) as u64) << 18)
-        | (((bytes[4]) as u64) << 10)
-        | (((bytes[5]) as u64) << 2)
+        | ((bytes[4] as u64) << 10)
+        | ((bytes[5] as u64) << 2)
         | (((bytes[6] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[6]) & 0x3f) as u64) << 19)
-        | (((bytes[7]) as u64) << 11)
-        | (((bytes[8]) as u64) << 3)
+        | ((bytes[7] as u64) << 11)
+        | ((bytes[8] as u64) << 3)
         | (((bytes[9] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[9]) & 0x1f) as u64) << 20)
-        | (((bytes[10]) as u64) << 12)
-        | (((bytes[11]) as u64) << 4)
+        | ((bytes[10] as u64) << 12)
+        | ((bytes[11] as u64) << 4)
         | (((bytes[12] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[12]) & 0xf) as u64) << 21)
-        | (((bytes[13]) as u64) << 13)
-        | (((bytes[14]) as u64) << 5)
+        | ((bytes[13] as u64) << 13)
+        | ((bytes[14] as u64) << 5)
         | (((bytes[15] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[15]) & 0x7) as u64) << 22)
-        | (((bytes[16]) as u64) << 14)
-        | (((bytes[17]) as u64) << 6)
+        | ((bytes[16] as u64) << 14)
+        | ((bytes[17] as u64) << 6)
         | (((bytes[18] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[18]) & 0x3) as u64) << 23)
-        | (((bytes[19]) as u64) << 15)
-        | (((bytes[20]) as u64) << 7)
+        | ((bytes[19] as u64) << 15)
+        | ((bytes[20] as u64) << 7)
         | (((bytes[21] >> 1) & 0x7f) as u64);
     values[7] = ((((bytes[21]) & 0x1) as u64) << 24)
-        | (((bytes[22]) as u64) << 16)
-        | (((bytes[23]) as u64) << 8)
-        | ((bytes[24]) as u64);
+        | ((bytes[22] as u64) << 16)
+        | ((bytes[23] as u64) << 8)
+        | (bytes[24] as u64);
 }
 
 #[inline]
 fn unpack_bits_26(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 18)
-        | (((bytes[1]) as u64) << 10)
-        | (((bytes[2]) as u64) << 2)
+    values[0] = ((bytes[0] as u64) << 18)
+        | ((bytes[1] as u64) << 10)
+        | ((bytes[2] as u64) << 2)
         | (((bytes[3] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[3]) & 0x3f) as u64) << 20)
-        | (((bytes[4]) as u64) << 12)
-        | (((bytes[5]) as u64) << 4)
+        | ((bytes[4] as u64) << 12)
+        | ((bytes[5] as u64) << 4)
         | (((bytes[6] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[6]) & 0xf) as u64) << 22)
-        | (((bytes[7]) as u64) << 14)
-        | (((bytes[8]) as u64) << 6)
+        | ((bytes[7] as u64) << 14)
+        | ((bytes[8] as u64) << 6)
         | (((bytes[9] >> 2) & 0x3f) as u64);
     values[3] = ((((bytes[9]) & 0x3) as u64) << 24)
-        | (((bytes[10]) as u64) << 16)
-        | (((bytes[11]) as u64) << 8)
-        | ((bytes[12]) as u64);
-    values[4] = (((bytes[13]) as u64) << 18)
-        | (((bytes[14]) as u64) << 10)
-        | (((bytes[15]) as u64) << 2)
+        | ((bytes[10] as u64) << 16)
+        | ((bytes[11] as u64) << 8)
+        | (bytes[12] as u64);
+    values[4] = ((bytes[13] as u64) << 18)
+        | ((bytes[14] as u64) << 10)
+        | ((bytes[15] as u64) << 2)
         | (((bytes[16] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[16]) & 0x3f) as u64) << 20)
-        | (((bytes[17]) as u64) << 12)
-        | (((bytes[18]) as u64) << 4)
+        | ((bytes[17] as u64) << 12)
+        | ((bytes[18] as u64) << 4)
         | (((bytes[19] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[19]) & 0xf) as u64) << 22)
-        | (((bytes[20]) as u64) << 14)
-        | (((bytes[21]) as u64) << 6)
+        | ((bytes[20] as u64) << 14)
+        | ((bytes[21] as u64) << 6)
         | (((bytes[22] >> 2) & 0x3f) as u64);
     values[7] = ((((bytes[22]) & 0x3) as u64) << 24)
-        | (((bytes[23]) as u64) << 16)
-        | (((bytes[24]) as u64) << 8)
-        | ((bytes[25]) as u64);
+        | ((bytes[23] as u64) << 16)
+        | ((bytes[24] as u64) << 8)
+        | (bytes[25] as u64);
 }
 
 #[inline]
 fn unpack_bits_27(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 19)
-        | (((bytes[1]) as u64) << 11)
-        | (((bytes[2]) as u64) << 3)
+    values[0] = ((bytes[0] as u64) << 19)
+        | ((bytes[1] as u64) << 11)
+        | ((bytes[2] as u64) << 3)
         | (((bytes[3] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[3]) & 0x1f) as u64) << 22)
-        | (((bytes[4]) as u64) << 14)
-        | (((bytes[5]) as u64) << 6)
+        | ((bytes[4] as u64) << 14)
+        | ((bytes[5] as u64) << 6)
         | (((bytes[6] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[6]) & 0x3) as u64) << 25)
-        | (((bytes[7]) as u64) << 17)
-        | (((bytes[8]) as u64) << 9)
-        | (((bytes[9]) as u64) << 1)
+        | ((bytes[7] as u64) << 17)
+        | ((bytes[8] as u64) << 9)
+        | ((bytes[9] as u64) << 1)
         | (((bytes[10] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[10]) & 0x7f) as u64) << 20)
-        | (((bytes[11]) as u64) << 12)
-        | (((bytes[12]) as u64) << 4)
+        | ((bytes[11] as u64) << 12)
+        | ((bytes[12] as u64) << 4)
         | (((bytes[13] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[13]) & 0xf) as u64) << 23)
-        | (((bytes[14]) as u64) << 15)
-        | (((bytes[15]) as u64) << 7)
+        | ((bytes[14] as u64) << 15)
+        | ((bytes[15] as u64) << 7)
         | (((bytes[16] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[16]) & 0x1) as u64) << 26)
-        | (((bytes[17]) as u64) << 18)
-        | (((bytes[18]) as u64) << 10)
-        | (((bytes[19]) as u64) << 2)
+        | ((bytes[17] as u64) << 18)
+        | ((bytes[18] as u64) << 10)
+        | ((bytes[19] as u64) << 2)
         | (((bytes[20] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[20]) & 0x3f) as u64) << 21)
-        | (((bytes[21]) as u64) << 13)
-        | (((bytes[22]) as u64) << 5)
+        | ((bytes[21] as u64) << 13)
+        | ((bytes[22] as u64) << 5)
         | (((bytes[23] >> 3) & 0x1f) as u64);
     values[7] = ((((bytes[23]) & 0x7) as u64) << 24)
-        | (((bytes[24]) as u64) << 16)
-        | (((bytes[25]) as u64) << 8)
-        | ((bytes[26]) as u64);
+        | ((bytes[24] as u64) << 16)
+        | ((bytes[25] as u64) << 8)
+        | (bytes[26] as u64);
 }
 
 #[inline]
 fn unpack_bits_28(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 20)
-        | (((bytes[1]) as u64) << 12)
-        | (((bytes[2]) as u64) << 4)
+    values[0] = ((bytes[0] as u64) << 20)
+        | ((bytes[1] as u64) << 12)
+        | ((bytes[2] as u64) << 4)
         | (((bytes[3] >> 4) & 0xf) as u64);
     values[1] = ((((bytes[3]) & 0xf) as u64) << 24)
-        | (((bytes[4]) as u64) << 16)
-        | (((bytes[5]) as u64) << 8)
-        | ((bytes[6]) as u64);
-    values[2] = (((bytes[7]) as u64) << 20)
-        | (((bytes[8]) as u64) << 12)
-        | (((bytes[9]) as u64) << 4)
+        | ((bytes[4] as u64) << 16)
+        | ((bytes[5] as u64) << 8)
+        | (bytes[6] as u64);
+    values[2] = ((bytes[7] as u64) << 20)
+        | ((bytes[8] as u64) << 12)
+        | ((bytes[9] as u64) << 4)
         | (((bytes[10] >> 4) & 0xf) as u64);
     values[3] = ((((bytes[10]) & 0xf) as u64) << 24)
-        | (((bytes[11]) as u64) << 16)
-        | (((bytes[12]) as u64) << 8)
-        | ((bytes[13]) as u64);
-    values[4] = (((bytes[14]) as u64) << 20)
-        | (((bytes[15]) as u64) << 12)
-        | (((bytes[16]) as u64) << 4)
+        | ((bytes[11] as u64) << 16)
+        | ((bytes[12] as u64) << 8)
+        | (bytes[13] as u64);
+    values[4] = ((bytes[14] as u64) << 20)
+        | ((bytes[15] as u64) << 12)
+        | ((bytes[16] as u64) << 4)
         | (((bytes[17] >> 4) & 0xf) as u64);
     values[5] = ((((bytes[17]) & 0xf) as u64) << 24)
-        | (((bytes[18]) as u64) << 16)
-        | (((bytes[19]) as u64) << 8)
-        | ((bytes[20]) as u64);
-    values[6] = (((bytes[21]) as u64) << 20)
-        | (((bytes[22]) as u64) << 12)
-        | (((bytes[23]) as u64) << 4)
+        | ((bytes[18] as u64) << 16)
+        | ((bytes[19] as u64) << 8)
+        | (bytes[20] as u64);
+    values[6] = ((bytes[21] as u64) << 20)
+        | ((bytes[22] as u64) << 12)
+        | ((bytes[23] as u64) << 4)
         | (((bytes[24] >> 4) & 0xf) as u64);
     values[7] = ((((bytes[24]) & 0xf) as u64) << 24)
-        | (((bytes[25]) as u64) << 16)
-        | (((bytes[26]) as u64) << 8)
-        | ((bytes[27]) as u64);
+        | ((bytes[25] as u64) << 16)
+        | ((bytes[26] as u64) << 8)
+        | (bytes[27] as u64);
 }
 
 #[inline]
 fn unpack_bits_29(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 21)
-        | (((bytes[1]) as u64) << 13)
-        | (((bytes[2]) as u64) << 5)
+    values[0] = ((bytes[0] as u64) << 21)
+        | ((bytes[1] as u64) << 13)
+        | ((bytes[2] as u64) << 5)
         | (((bytes[3] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[3]) & 0x7) as u64) << 26)
-        | (((bytes[4]) as u64) << 18)
-        | (((bytes[5]) as u64) << 10)
-        | (((bytes[6]) as u64) << 2)
+        | ((bytes[4] as u64) << 18)
+        | ((bytes[5] as u64) << 10)
+        | ((bytes[6] as u64) << 2)
         | (((bytes[7] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[7]) & 0x3f) as u64) << 23)
-        | (((bytes[8]) as u64) << 15)
-        | (((bytes[9]) as u64) << 7)
+        | ((bytes[8] as u64) << 15)
+        | ((bytes[9] as u64) << 7)
         | (((bytes[10] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[10]) & 0x1) as u64) << 28)
-        | (((bytes[11]) as u64) << 20)
-        | (((bytes[12]) as u64) << 12)
-        | (((bytes[13]) as u64) << 4)
+        | ((bytes[11] as u64) << 20)
+        | ((bytes[12] as u64) << 12)
+        | ((bytes[13] as u64) << 4)
         | (((bytes[14] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[14]) & 0xf) as u64) << 25)
-        | (((bytes[15]) as u64) << 17)
-        | (((bytes[16]) as u64) << 9)
-        | (((bytes[17]) as u64) << 1)
+        | ((bytes[15] as u64) << 17)
+        | ((bytes[16] as u64) << 9)
+        | ((bytes[17] as u64) << 1)
         | (((bytes[18] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[18]) & 0x7f) as u64) << 22)
-        | (((bytes[19]) as u64) << 14)
-        | (((bytes[20]) as u64) << 6)
+        | ((bytes[19] as u64) << 14)
+        | ((bytes[20] as u64) << 6)
         | (((bytes[21] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[21]) & 0x3) as u64) << 27)
-        | (((bytes[22]) as u64) << 19)
-        | (((bytes[23]) as u64) << 11)
-        | (((bytes[24]) as u64) << 3)
+        | ((bytes[22] as u64) << 19)
+        | ((bytes[23] as u64) << 11)
+        | ((bytes[24] as u64) << 3)
         | (((bytes[25] >> 5) & 0x7) as u64);
     values[7] = ((((bytes[25]) & 0x1f) as u64) << 24)
-        | (((bytes[26]) as u64) << 16)
-        | (((bytes[27]) as u64) << 8)
-        | ((bytes[28]) as u64);
+        | ((bytes[26] as u64) << 16)
+        | ((bytes[27] as u64) << 8)
+        | (bytes[28] as u64);
 }
 
 #[inline]
 fn unpack_bits_30(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 22)
-        | (((bytes[1]) as u64) << 14)
-        | (((bytes[2]) as u64) << 6)
+    values[0] = ((bytes[0] as u64) << 22)
+        | ((bytes[1] as u64) << 14)
+        | ((bytes[2] as u64) << 6)
         | (((bytes[3] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[3]) & 0x3) as u64) << 28)
-        | (((bytes[4]) as u64) << 20)
-        | (((bytes[5]) as u64) << 12)
-        | (((bytes[6]) as u64) << 4)
+        | ((bytes[4] as u64) << 20)
+        | ((bytes[5] as u64) << 12)
+        | ((bytes[6] as u64) << 4)
         | (((bytes[7] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[7]) & 0xf) as u64) << 26)
-        | (((bytes[8]) as u64) << 18)
-        | (((bytes[9]) as u64) << 10)
-        | (((bytes[10]) as u64) << 2)
+        | ((bytes[8] as u64) << 18)
+        | ((bytes[9] as u64) << 10)
+        | ((bytes[10] as u64) << 2)
         | (((bytes[11] >> 6) & 0x3) as u64);
     values[3] = ((((bytes[11]) & 0x3f) as u64) << 24)
-        | (((bytes[12]) as u64) << 16)
-        | (((bytes[13]) as u64) << 8)
-        | ((bytes[14]) as u64);
-    values[4] = (((bytes[15]) as u64) << 22)
-        | (((bytes[16]) as u64) << 14)
-        | (((bytes[17]) as u64) << 6)
+        | ((bytes[12] as u64) << 16)
+        | ((bytes[13] as u64) << 8)
+        | (bytes[14] as u64);
+    values[4] = ((bytes[15] as u64) << 22)
+        | ((bytes[16] as u64) << 14)
+        | ((bytes[17] as u64) << 6)
         | (((bytes[18] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[18]) & 0x3) as u64) << 28)
-        | (((bytes[19]) as u64) << 20)
-        | (((bytes[20]) as u64) << 12)
-        | (((bytes[21]) as u64) << 4)
+        | ((bytes[19] as u64) << 20)
+        | ((bytes[20] as u64) << 12)
+        | ((bytes[21] as u64) << 4)
         | (((bytes[22] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[22]) & 0xf) as u64) << 26)
-        | (((bytes[23]) as u64) << 18)
-        | (((bytes[24]) as u64) << 10)
-        | (((bytes[25]) as u64) << 2)
+        | ((bytes[23] as u64) << 18)
+        | ((bytes[24] as u64) << 10)
+        | ((bytes[25] as u64) << 2)
         | (((bytes[26] >> 6) & 0x3) as u64);
     values[7] = ((((bytes[26]) & 0x3f) as u64) << 24)
-        | (((bytes[27]) as u64) << 16)
-        | (((bytes[28]) as u64) << 8)
-        | ((bytes[29]) as u64);
+        | ((bytes[27] as u64) << 16)
+        | ((bytes[28] as u64) << 8)
+        | (bytes[29] as u64);
 }
 
 #[inline]
 fn unpack_bits_31(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 23)
-        | (((bytes[1]) as u64) << 15)
-        | (((bytes[2]) as u64) << 7)
+    values[0] = ((bytes[0] as u64) << 23)
+        | ((bytes[1] as u64) << 15)
+        | ((bytes[2] as u64) << 7)
         | (((bytes[3] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[3]) & 0x1) as u64) << 30)
-        | (((bytes[4]) as u64) << 22)
-        | (((bytes[5]) as u64) << 14)
-        | (((bytes[6]) as u64) << 6)
+        | ((bytes[4] as u64) << 22)
+        | ((bytes[5] as u64) << 14)
+        | ((bytes[6] as u64) << 6)
         | (((bytes[7] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[7]) & 0x3) as u64) << 29)
-        | (((bytes[8]) as u64) << 21)
-        | (((bytes[9]) as u64) << 13)
-        | (((bytes[10]) as u64) << 5)
+        | ((bytes[8] as u64) << 21)
+        | ((bytes[9] as u64) << 13)
+        | ((bytes[10] as u64) << 5)
         | (((bytes[11] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[11]) & 0x7) as u64) << 28)
-        | (((bytes[12]) as u64) << 20)
-        | (((bytes[13]) as u64) << 12)
-        | (((bytes[14]) as u64) << 4)
+        | ((bytes[12] as u64) << 20)
+        | ((bytes[13] as u64) << 12)
+        | ((bytes[14] as u64) << 4)
         | (((bytes[15] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[15]) & 0xf) as u64) << 27)
-        | (((bytes[16]) as u64) << 19)
-        | (((bytes[17]) as u64) << 11)
-        | (((bytes[18]) as u64) << 3)
+        | ((bytes[16] as u64) << 19)
+        | ((bytes[17] as u64) << 11)
+        | ((bytes[18] as u64) << 3)
         | (((bytes[19] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[19]) & 0x1f) as u64) << 26)
-        | (((bytes[20]) as u64) << 18)
-        | (((bytes[21]) as u64) << 10)
-        | (((bytes[22]) as u64) << 2)
+        | ((bytes[20] as u64) << 18)
+        | ((bytes[21] as u64) << 10)
+        | ((bytes[22] as u64) << 2)
         | (((bytes[23] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[23]) & 0x3f) as u64) << 25)
-        | (((bytes[24]) as u64) << 17)
-        | (((bytes[25]) as u64) << 9)
-        | (((bytes[26]) as u64) << 1)
+        | ((bytes[24] as u64) << 17)
+        | ((bytes[25] as u64) << 9)
+        | ((bytes[26] as u64) << 1)
         | (((bytes[27] >> 7) & 0x1) as u64);
     values[7] = ((((bytes[27]) & 0x7f) as u64) << 24)
-        | (((bytes[28]) as u64) << 16)
-        | (((bytes[29]) as u64) << 8)
-        | ((bytes[30]) as u64);
+        | ((bytes[28] as u64) << 16)
+        | ((bytes[29] as u64) << 8)
+        | (bytes[30] as u64);
 }
 
 #[inline]
 fn unpack_bits_32(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 24)
-        | (((bytes[1]) as u64) << 16)
-        | (((bytes[2]) as u64) << 8)
-        | ((bytes[3]) as u64);
-    values[1] = (((bytes[4]) as u64) << 24)
-        | (((bytes[5]) as u64) << 16)
-        | (((bytes[6]) as u64) << 8)
-        | ((bytes[7]) as u64);
-    values[2] = (((bytes[8]) as u64) << 24)
-        | (((bytes[9]) as u64) << 16)
-        | (((bytes[10]) as u64) << 8)
-        | ((bytes[11]) as u64);
-    values[3] = (((bytes[12]) as u64) << 24)
-        | (((bytes[13]) as u64) << 16)
-        | (((bytes[14]) as u64) << 8)
-        | ((bytes[15]) as u64);
-    values[4] = (((bytes[16]) as u64) << 24)
-        | (((bytes[17]) as u64) << 16)
-        | (((bytes[18]) as u64) << 8)
-        | ((bytes[19]) as u64);
-    values[5] = (((bytes[20]) as u64) << 24)
-        | (((bytes[21]) as u64) << 16)
-        | (((bytes[22]) as u64) << 8)
-        | ((bytes[23]) as u64);
-    values[6] = (((bytes[24]) as u64) << 24)
-        | (((bytes[25]) as u64) << 16)
-        | (((bytes[26]) as u64) << 8)
-        | ((bytes[27]) as u64);
-    values[7] = (((bytes[28]) as u64) << 24)
-        | (((bytes[29]) as u64) << 16)
-        | (((bytes[30]) as u64) << 8)
-        | ((bytes[31]) as u64);
+    values[0] = ((bytes[0] as u64) << 24)
+        | ((bytes[1] as u64) << 16)
+        | ((bytes[2] as u64) << 8)
+        | (bytes[3] as u64);
+    values[1] = ((bytes[4] as u64) << 24)
+        | ((bytes[5] as u64) << 16)
+        | ((bytes[6] as u64) << 8)
+        | (bytes[7] as u64);
+    values[2] = ((bytes[8] as u64) << 24)
+        | ((bytes[9] as u64) << 16)
+        | ((bytes[10] as u64) << 8)
+        | (bytes[11] as u64);
+    values[3] = ((bytes[12] as u64) << 24)
+        | ((bytes[13] as u64) << 16)
+        | ((bytes[14] as u64) << 8)
+        | (bytes[15] as u64);
+    values[4] = ((bytes[16] as u64) << 24)
+        | ((bytes[17] as u64) << 16)
+        | ((bytes[18] as u64) << 8)
+        | (bytes[19] as u64);
+    values[5] = ((bytes[20] as u64) << 24)
+        | ((bytes[21] as u64) << 16)
+        | ((bytes[22] as u64) << 8)
+        | (bytes[23] as u64);
+    values[6] = ((bytes[24] as u64) << 24)
+        | ((bytes[25] as u64) << 16)
+        | ((bytes[26] as u64) << 8)
+        | (bytes[27] as u64);
+    values[7] = ((bytes[28] as u64) << 24)
+        | ((bytes[29] as u64) << 16)
+        | ((bytes[30] as u64) << 8)
+        | (bytes[31] as u64);
 }
 
 #[inline]
 fn unpack_bits_33(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 25)
-        | (((bytes[1]) as u64) << 17)
-        | (((bytes[2]) as u64) << 9)
-        | (((bytes[3]) as u64) << 1)
+    values[0] = ((bytes[0] as u64) << 25)
+        | ((bytes[1] as u64) << 17)
+        | ((bytes[2] as u64) << 9)
+        | ((bytes[3] as u64) << 1)
         | (((bytes[4] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[4]) & 0x7f) as u64) << 26)
-        | (((bytes[5]) as u64) << 18)
-        | (((bytes[6]) as u64) << 10)
-        | (((bytes[7]) as u64) << 2)
+        | ((bytes[5] as u64) << 18)
+        | ((bytes[6] as u64) << 10)
+        | ((bytes[7] as u64) << 2)
         | (((bytes[8] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[8]) & 0x3f) as u64) << 27)
-        | (((bytes[9]) as u64) << 19)
-        | (((bytes[10]) as u64) << 11)
-        | (((bytes[11]) as u64) << 3)
+        | ((bytes[9] as u64) << 19)
+        | ((bytes[10] as u64) << 11)
+        | ((bytes[11] as u64) << 3)
         | (((bytes[12] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[12]) & 0x1f) as u64) << 28)
-        | (((bytes[13]) as u64) << 20)
-        | (((bytes[14]) as u64) << 12)
-        | (((bytes[15]) as u64) << 4)
+        | ((bytes[13] as u64) << 20)
+        | ((bytes[14] as u64) << 12)
+        | ((bytes[15] as u64) << 4)
         | (((bytes[16] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[16]) & 0xf) as u64) << 29)
-        | (((bytes[17]) as u64) << 21)
-        | (((bytes[18]) as u64) << 13)
-        | (((bytes[19]) as u64) << 5)
+        | ((bytes[17] as u64) << 21)
+        | ((bytes[18] as u64) << 13)
+        | ((bytes[19] as u64) << 5)
         | (((bytes[20] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[20]) & 0x7) as u64) << 30)
-        | (((bytes[21]) as u64) << 22)
-        | (((bytes[22]) as u64) << 14)
-        | (((bytes[23]) as u64) << 6)
+        | ((bytes[21] as u64) << 22)
+        | ((bytes[22] as u64) << 14)
+        | ((bytes[23] as u64) << 6)
         | (((bytes[24] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[24]) & 0x3) as u64) << 31)
-        | (((bytes[25]) as u64) << 23)
-        | (((bytes[26]) as u64) << 15)
-        | (((bytes[27]) as u64) << 7)
+        | ((bytes[25] as u64) << 23)
+        | ((bytes[26] as u64) << 15)
+        | ((bytes[27] as u64) << 7)
         | (((bytes[28] >> 1) & 0x7f) as u64);
     values[7] = ((((bytes[28]) & 0x1) as u64) << 32)
-        | (((bytes[29]) as u64) << 24)
-        | (((bytes[30]) as u64) << 16)
-        | (((bytes[31]) as u64) << 8)
-        | ((bytes[32]) as u64);
+        | ((bytes[29] as u64) << 24)
+        | ((bytes[30] as u64) << 16)
+        | ((bytes[31] as u64) << 8)
+        | (bytes[32] as u64);
 }
 
 #[inline]
 fn unpack_bits_34(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 26)
-        | (((bytes[1]) as u64) << 18)
-        | (((bytes[2]) as u64) << 10)
-        | (((bytes[3]) as u64) << 2)
+    values[0] = ((bytes[0] as u64) << 26)
+        | ((bytes[1] as u64) << 18)
+        | ((bytes[2] as u64) << 10)
+        | ((bytes[3] as u64) << 2)
         | (((bytes[4] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[4]) & 0x3f) as u64) << 28)
-        | (((bytes[5]) as u64) << 20)
-        | (((bytes[6]) as u64) << 12)
-        | (((bytes[7]) as u64) << 4)
+        | ((bytes[5] as u64) << 20)
+        | ((bytes[6] as u64) << 12)
+        | ((bytes[7] as u64) << 4)
         | (((bytes[8] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[8]) & 0xf) as u64) << 30)
-        | (((bytes[9]) as u64) << 22)
-        | (((bytes[10]) as u64) << 14)
-        | (((bytes[11]) as u64) << 6)
+        | ((bytes[9] as u64) << 22)
+        | ((bytes[10] as u64) << 14)
+        | ((bytes[11] as u64) << 6)
         | (((bytes[12] >> 2) & 0x3f) as u64);
     values[3] = ((((bytes[12]) & 0x3) as u64) << 32)
-        | (((bytes[13]) as u64) << 24)
-        | (((bytes[14]) as u64) << 16)
-        | (((bytes[15]) as u64) << 8)
-        | ((bytes[16]) as u64);
-    values[4] = (((bytes[17]) as u64) << 26)
-        | (((bytes[18]) as u64) << 18)
-        | (((bytes[19]) as u64) << 10)
-        | (((bytes[20]) as u64) << 2)
+        | ((bytes[13] as u64) << 24)
+        | ((bytes[14] as u64) << 16)
+        | ((bytes[15] as u64) << 8)
+        | (bytes[16] as u64);
+    values[4] = ((bytes[17] as u64) << 26)
+        | ((bytes[18] as u64) << 18)
+        | ((bytes[19] as u64) << 10)
+        | ((bytes[20] as u64) << 2)
         | (((bytes[21] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[21]) & 0x3f) as u64) << 28)
-        | (((bytes[22]) as u64) << 20)
-        | (((bytes[23]) as u64) << 12)
-        | (((bytes[24]) as u64) << 4)
+        | ((bytes[22] as u64) << 20)
+        | ((bytes[23] as u64) << 12)
+        | ((bytes[24] as u64) << 4)
         | (((bytes[25] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[25]) & 0xf) as u64) << 30)
-        | (((bytes[26]) as u64) << 22)
-        | (((bytes[27]) as u64) << 14)
-        | (((bytes[28]) as u64) << 6)
+        | ((bytes[26] as u64) << 22)
+        | ((bytes[27] as u64) << 14)
+        | ((bytes[28] as u64) << 6)
         | (((bytes[29] >> 2) & 0x3f) as u64);
     values[7] = ((((bytes[29]) & 0x3) as u64) << 32)
-        | (((bytes[30]) as u64) << 24)
-        | (((bytes[31]) as u64) << 16)
-        | (((bytes[32]) as u64) << 8)
-        | ((bytes[33]) as u64);
+        | ((bytes[30] as u64) << 24)
+        | ((bytes[31] as u64) << 16)
+        | ((bytes[32] as u64) << 8)
+        | (bytes[33] as u64);
 }
 
 #[inline]
 fn unpack_bits_35(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 27)
-        | (((bytes[1]) as u64) << 19)
-        | (((bytes[2]) as u64) << 11)
-        | (((bytes[3]) as u64) << 3)
+    values[0] = ((bytes[0] as u64) << 27)
+        | ((bytes[1] as u64) << 19)
+        | ((bytes[2] as u64) << 11)
+        | ((bytes[3] as u64) << 3)
         | (((bytes[4] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[4]) & 0x1f) as u64) << 30)
-        | (((bytes[5]) as u64) << 22)
-        | (((bytes[6]) as u64) << 14)
-        | (((bytes[7]) as u64) << 6)
+        | ((bytes[5] as u64) << 22)
+        | ((bytes[6] as u64) << 14)
+        | ((bytes[7] as u64) << 6)
         | (((bytes[8] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[8]) & 0x3) as u64) << 33)
-        | (((bytes[9]) as u64) << 25)
-        | (((bytes[10]) as u64) << 17)
-        | (((bytes[11]) as u64) << 9)
-        | (((bytes[12]) as u64) << 1)
+        | ((bytes[9] as u64) << 25)
+        | ((bytes[10] as u64) << 17)
+        | ((bytes[11] as u64) << 9)
+        | ((bytes[12] as u64) << 1)
         | (((bytes[13] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[13]) & 0x7f) as u64) << 28)
-        | (((bytes[14]) as u64) << 20)
-        | (((bytes[15]) as u64) << 12)
-        | (((bytes[16]) as u64) << 4)
+        | ((bytes[14] as u64) << 20)
+        | ((bytes[15] as u64) << 12)
+        | ((bytes[16] as u64) << 4)
         | (((bytes[17] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[17]) & 0xf) as u64) << 31)
-        | (((bytes[18]) as u64) << 23)
-        | (((bytes[19]) as u64) << 15)
-        | (((bytes[20]) as u64) << 7)
+        | ((bytes[18] as u64) << 23)
+        | ((bytes[19] as u64) << 15)
+        | ((bytes[20] as u64) << 7)
         | (((bytes[21] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[21]) & 0x1) as u64) << 34)
-        | (((bytes[22]) as u64) << 26)
-        | (((bytes[23]) as u64) << 18)
-        | (((bytes[24]) as u64) << 10)
-        | (((bytes[25]) as u64) << 2)
+        | ((bytes[22] as u64) << 26)
+        | ((bytes[23] as u64) << 18)
+        | ((bytes[24] as u64) << 10)
+        | ((bytes[25] as u64) << 2)
         | (((bytes[26] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[26]) & 0x3f) as u64) << 29)
-        | (((bytes[27]) as u64) << 21)
-        | (((bytes[28]) as u64) << 13)
-        | (((bytes[29]) as u64) << 5)
+        | ((bytes[27] as u64) << 21)
+        | ((bytes[28] as u64) << 13)
+        | ((bytes[29] as u64) << 5)
         | (((bytes[30] >> 3) & 0x1f) as u64);
     values[7] = ((((bytes[30]) & 0x7) as u64) << 32)
-        | (((bytes[31]) as u64) << 24)
-        | (((bytes[32]) as u64) << 16)
-        | (((bytes[33]) as u64) << 8)
-        | ((bytes[34]) as u64);
+        | ((bytes[31] as u64) << 24)
+        | ((bytes[32] as u64) << 16)
+        | ((bytes[33] as u64) << 8)
+        | (bytes[34] as u64);
 }
 
 #[inline]
 fn unpack_bits_36(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 28)
-        | (((bytes[1]) as u64) << 20)
-        | (((bytes[2]) as u64) << 12)
-        | (((bytes[3]) as u64) << 4)
+    values[0] = ((bytes[0] as u64) << 28)
+        | ((bytes[1] as u64) << 20)
+        | ((bytes[2] as u64) << 12)
+        | ((bytes[3] as u64) << 4)
         | (((bytes[4] >> 4) & 0xf) as u64);
     values[1] = ((((bytes[4]) & 0xf) as u64) << 32)
-        | (((bytes[5]) as u64) << 24)
-        | (((bytes[6]) as u64) << 16)
-        | (((bytes[7]) as u64) << 8)
-        | ((bytes[8]) as u64);
-    values[2] = (((bytes[9]) as u64) << 28)
-        | (((bytes[10]) as u64) << 20)
-        | (((bytes[11]) as u64) << 12)
-        | (((bytes[12]) as u64) << 4)
+        | ((bytes[5] as u64) << 24)
+        | ((bytes[6] as u64) << 16)
+        | ((bytes[7] as u64) << 8)
+        | (bytes[8] as u64);
+    values[2] = ((bytes[9] as u64) << 28)
+        | ((bytes[10] as u64) << 20)
+        | ((bytes[11] as u64) << 12)
+        | ((bytes[12] as u64) << 4)
         | (((bytes[13] >> 4) & 0xf) as u64);
     values[3] = ((((bytes[13]) & 0xf) as u64) << 32)
-        | (((bytes[14]) as u64) << 24)
-        | (((bytes[15]) as u64) << 16)
-        | (((bytes[16]) as u64) << 8)
-        | ((bytes[17]) as u64);
-    values[4] = (((bytes[18]) as u64) << 28)
-        | (((bytes[19]) as u64) << 20)
-        | (((bytes[20]) as u64) << 12)
-        | (((bytes[21]) as u64) << 4)
+        | ((bytes[14] as u64) << 24)
+        | ((bytes[15] as u64) << 16)
+        | ((bytes[16] as u64) << 8)
+        | (bytes[17] as u64);
+    values[4] = ((bytes[18] as u64) << 28)
+        | ((bytes[19] as u64) << 20)
+        | ((bytes[20] as u64) << 12)
+        | ((bytes[21] as u64) << 4)
         | (((bytes[22] >> 4) & 0xf) as u64);
     values[5] = ((((bytes[22]) & 0xf) as u64) << 32)
-        | (((bytes[23]) as u64) << 24)
-        | (((bytes[24]) as u64) << 16)
-        | (((bytes[25]) as u64) << 8)
-        | ((bytes[26]) as u64);
-    values[6] = (((bytes[27]) as u64) << 28)
-        | (((bytes[28]) as u64) << 20)
-        | (((bytes[29]) as u64) << 12)
-        | (((bytes[30]) as u64) << 4)
+        | ((bytes[23] as u64) << 24)
+        | ((bytes[24] as u64) << 16)
+        | ((bytes[25] as u64) << 8)
+        | (bytes[26] as u64);
+    values[6] = ((bytes[27] as u64) << 28)
+        | ((bytes[28] as u64) << 20)
+        | ((bytes[29] as u64) << 12)
+        | ((bytes[30] as u64) << 4)
         | (((bytes[31] >> 4) & 0xf) as u64);
     values[7] = ((((bytes[31]) & 0xf) as u64) << 32)
-        | (((bytes[32]) as u64) << 24)
-        | (((bytes[33]) as u64) << 16)
-        | (((bytes[34]) as u64) << 8)
-        | ((bytes[35]) as u64);
+        | ((bytes[32] as u64) << 24)
+        | ((bytes[33] as u64) << 16)
+        | ((bytes[34] as u64) << 8)
+        | (bytes[35] as u64);
 }
 
 #[inline]
 fn unpack_bits_37(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 29)
-        | (((bytes[1]) as u64) << 21)
-        | (((bytes[2]) as u64) << 13)
-        | (((bytes[3]) as u64) << 5)
+    values[0] = ((bytes[0] as u64) << 29)
+        | ((bytes[1] as u64) << 21)
+        | ((bytes[2] as u64) << 13)
+        | ((bytes[3] as u64) << 5)
         | (((bytes[4] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[4]) & 0x7) as u64) << 34)
-        | (((bytes[5]) as u64) << 26)
-        | (((bytes[6]) as u64) << 18)
-        | (((bytes[7]) as u64) << 10)
-        | (((bytes[8]) as u64) << 2)
+        | ((bytes[5] as u64) << 26)
+        | ((bytes[6] as u64) << 18)
+        | ((bytes[7] as u64) << 10)
+        | ((bytes[8] as u64) << 2)
         | (((bytes[9] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[9]) & 0x3f) as u64) << 31)
-        | (((bytes[10]) as u64) << 23)
-        | (((bytes[11]) as u64) << 15)
-        | (((bytes[12]) as u64) << 7)
+        | ((bytes[10] as u64) << 23)
+        | ((bytes[11] as u64) << 15)
+        | ((bytes[12] as u64) << 7)
         | (((bytes[13] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[13]) & 0x1) as u64) << 36)
-        | (((bytes[14]) as u64) << 28)
-        | (((bytes[15]) as u64) << 20)
-        | (((bytes[16]) as u64) << 12)
-        | (((bytes[17]) as u64) << 4)
+        | ((bytes[14] as u64) << 28)
+        | ((bytes[15] as u64) << 20)
+        | ((bytes[16] as u64) << 12)
+        | ((bytes[17] as u64) << 4)
         | (((bytes[18] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[18]) & 0xf) as u64) << 33)
-        | (((bytes[19]) as u64) << 25)
-        | (((bytes[20]) as u64) << 17)
-        | (((bytes[21]) as u64) << 9)
-        | (((bytes[22]) as u64) << 1)
+        | ((bytes[19] as u64) << 25)
+        | ((bytes[20] as u64) << 17)
+        | ((bytes[21] as u64) << 9)
+        | ((bytes[22] as u64) << 1)
         | (((bytes[23] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[23]) & 0x7f) as u64) << 30)
-        | (((bytes[24]) as u64) << 22)
-        | (((bytes[25]) as u64) << 14)
-        | (((bytes[26]) as u64) << 6)
+        | ((bytes[24] as u64) << 22)
+        | ((bytes[25] as u64) << 14)
+        | ((bytes[26] as u64) << 6)
         | (((bytes[27] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[27]) & 0x3) as u64) << 35)
-        | (((bytes[28]) as u64) << 27)
-        | (((bytes[29]) as u64) << 19)
-        | (((bytes[30]) as u64) << 11)
-        | (((bytes[31]) as u64) << 3)
+        | ((bytes[28] as u64) << 27)
+        | ((bytes[29] as u64) << 19)
+        | ((bytes[30] as u64) << 11)
+        | ((bytes[31] as u64) << 3)
         | (((bytes[32] >> 5) & 0x7) as u64);
     values[7] = ((((bytes[32]) & 0x1f) as u64) << 32)
-        | (((bytes[33]) as u64) << 24)
-        | (((bytes[34]) as u64) << 16)
-        | (((bytes[35]) as u64) << 8)
-        | ((bytes[36]) as u64);
+        | ((bytes[33] as u64) << 24)
+        | ((bytes[34] as u64) << 16)
+        | ((bytes[35] as u64) << 8)
+        | (bytes[36] as u64);
 }
 
 #[inline]
 fn unpack_bits_38(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 30)
-        | (((bytes[1]) as u64) << 22)
-        | (((bytes[2]) as u64) << 14)
-        | (((bytes[3]) as u64) << 6)
+    values[0] = ((bytes[0] as u64) << 30)
+        | ((bytes[1] as u64) << 22)
+        | ((bytes[2] as u64) << 14)
+        | ((bytes[3] as u64) << 6)
         | (((bytes[4] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[4]) & 0x3) as u64) << 36)
-        | (((bytes[5]) as u64) << 28)
-        | (((bytes[6]) as u64) << 20)
-        | (((bytes[7]) as u64) << 12)
-        | (((bytes[8]) as u64) << 4)
+        | ((bytes[5] as u64) << 28)
+        | ((bytes[6] as u64) << 20)
+        | ((bytes[7] as u64) << 12)
+        | ((bytes[8] as u64) << 4)
         | (((bytes[9] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[9]) & 0xf) as u64) << 34)
-        | (((bytes[10]) as u64) << 26)
-        | (((bytes[11]) as u64) << 18)
-        | (((bytes[12]) as u64) << 10)
-        | (((bytes[13]) as u64) << 2)
+        | ((bytes[10] as u64) << 26)
+        | ((bytes[11] as u64) << 18)
+        | ((bytes[12] as u64) << 10)
+        | ((bytes[13] as u64) << 2)
         | (((bytes[14] >> 6) & 0x3) as u64);
     values[3] = ((((bytes[14]) & 0x3f) as u64) << 32)
-        | (((bytes[15]) as u64) << 24)
-        | (((bytes[16]) as u64) << 16)
-        | (((bytes[17]) as u64) << 8)
-        | ((bytes[18]) as u64);
-    values[4] = (((bytes[19]) as u64) << 30)
-        | (((bytes[20]) as u64) << 22)
-        | (((bytes[21]) as u64) << 14)
-        | (((bytes[22]) as u64) << 6)
+        | ((bytes[15] as u64) << 24)
+        | ((bytes[16] as u64) << 16)
+        | ((bytes[17] as u64) << 8)
+        | (bytes[18] as u64);
+    values[4] = ((bytes[19] as u64) << 30)
+        | ((bytes[20] as u64) << 22)
+        | ((bytes[21] as u64) << 14)
+        | ((bytes[22] as u64) << 6)
         | (((bytes[23] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[23]) & 0x3) as u64) << 36)
-        | (((bytes[24]) as u64) << 28)
-        | (((bytes[25]) as u64) << 20)
-        | (((bytes[26]) as u64) << 12)
-        | (((bytes[27]) as u64) << 4)
+        | ((bytes[24] as u64) << 28)
+        | ((bytes[25] as u64) << 20)
+        | ((bytes[26] as u64) << 12)
+        | ((bytes[27] as u64) << 4)
         | (((bytes[28] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[28]) & 0xf) as u64) << 34)
-        | (((bytes[29]) as u64) << 26)
-        | (((bytes[30]) as u64) << 18)
-        | (((bytes[31]) as u64) << 10)
-        | (((bytes[32]) as u64) << 2)
+        | ((bytes[29] as u64) << 26)
+        | ((bytes[30] as u64) << 18)
+        | ((bytes[31] as u64) << 10)
+        | ((bytes[32] as u64) << 2)
         | (((bytes[33] >> 6) & 0x3) as u64);
     values[7] = ((((bytes[33]) & 0x3f) as u64) << 32)
-        | (((bytes[34]) as u64) << 24)
-        | (((bytes[35]) as u64) << 16)
-        | (((bytes[36]) as u64) << 8)
-        | ((bytes[37]) as u64);
+        | ((bytes[34] as u64) << 24)
+        | ((bytes[35] as u64) << 16)
+        | ((bytes[36] as u64) << 8)
+        | (bytes[37] as u64);
 }
 
 #[inline]
 fn unpack_bits_39(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 31)
-        | (((bytes[1]) as u64) << 23)
-        | (((bytes[2]) as u64) << 15)
-        | (((bytes[3]) as u64) << 7)
+    values[0] = ((bytes[0] as u64) << 31)
+        | ((bytes[1] as u64) << 23)
+        | ((bytes[2] as u64) << 15)
+        | ((bytes[3] as u64) << 7)
         | (((bytes[4] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[4]) & 0x1) as u64) << 38)
-        | (((bytes[5]) as u64) << 30)
-        | (((bytes[6]) as u64) << 22)
-        | (((bytes[7]) as u64) << 14)
-        | (((bytes[8]) as u64) << 6)
+        | ((bytes[5] as u64) << 30)
+        | ((bytes[6] as u64) << 22)
+        | ((bytes[7] as u64) << 14)
+        | ((bytes[8] as u64) << 6)
         | (((bytes[9] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[9]) & 0x3) as u64) << 37)
-        | (((bytes[10]) as u64) << 29)
-        | (((bytes[11]) as u64) << 21)
-        | (((bytes[12]) as u64) << 13)
-        | (((bytes[13]) as u64) << 5)
+        | ((bytes[10] as u64) << 29)
+        | ((bytes[11] as u64) << 21)
+        | ((bytes[12] as u64) << 13)
+        | ((bytes[13] as u64) << 5)
         | (((bytes[14] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[14]) & 0x7) as u64) << 36)
-        | (((bytes[15]) as u64) << 28)
-        | (((bytes[16]) as u64) << 20)
-        | (((bytes[17]) as u64) << 12)
-        | (((bytes[18]) as u64) << 4)
+        | ((bytes[15] as u64) << 28)
+        | ((bytes[16] as u64) << 20)
+        | ((bytes[17] as u64) << 12)
+        | ((bytes[18] as u64) << 4)
         | (((bytes[19] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[19]) & 0xf) as u64) << 35)
-        | (((bytes[20]) as u64) << 27)
-        | (((bytes[21]) as u64) << 19)
-        | (((bytes[22]) as u64) << 11)
-        | (((bytes[23]) as u64) << 3)
+        | ((bytes[20] as u64) << 27)
+        | ((bytes[21] as u64) << 19)
+        | ((bytes[22] as u64) << 11)
+        | ((bytes[23] as u64) << 3)
         | (((bytes[24] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[24]) & 0x1f) as u64) << 34)
-        | (((bytes[25]) as u64) << 26)
-        | (((bytes[26]) as u64) << 18)
-        | (((bytes[27]) as u64) << 10)
-        | (((bytes[28]) as u64) << 2)
+        | ((bytes[25] as u64) << 26)
+        | ((bytes[26] as u64) << 18)
+        | ((bytes[27] as u64) << 10)
+        | ((bytes[28] as u64) << 2)
         | (((bytes[29] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[29]) & 0x3f) as u64) << 33)
-        | (((bytes[30]) as u64) << 25)
-        | (((bytes[31]) as u64) << 17)
-        | (((bytes[32]) as u64) << 9)
-        | (((bytes[33]) as u64) << 1)
+        | ((bytes[30] as u64) << 25)
+        | ((bytes[31] as u64) << 17)
+        | ((bytes[32] as u64) << 9)
+        | ((bytes[33] as u64) << 1)
         | (((bytes[34] >> 7) & 0x1) as u64);
     values[7] = ((((bytes[34]) & 0x7f) as u64) << 32)
-        | (((bytes[35]) as u64) << 24)
-        | (((bytes[36]) as u64) << 16)
-        | (((bytes[37]) as u64) << 8)
-        | ((bytes[38]) as u64);
+        | ((bytes[35] as u64) << 24)
+        | ((bytes[36] as u64) << 16)
+        | ((bytes[37] as u64) << 8)
+        | (bytes[38] as u64);
 }
 
 #[inline]
 fn unpack_bits_40(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 32)
-        | (((bytes[1]) as u64) << 24)
-        | (((bytes[2]) as u64) << 16)
-        | (((bytes[3]) as u64) << 8)
-        | ((bytes[4]) as u64);
-    values[1] = (((bytes[5]) as u64) << 32)
-        | (((bytes[6]) as u64) << 24)
-        | (((bytes[7]) as u64) << 16)
-        | (((bytes[8]) as u64) << 8)
-        | ((bytes[9]) as u64);
-    values[2] = (((bytes[10]) as u64) << 32)
-        | (((bytes[11]) as u64) << 24)
-        | (((bytes[12]) as u64) << 16)
-        | (((bytes[13]) as u64) << 8)
-        | ((bytes[14]) as u64);
-    values[3] = (((bytes[15]) as u64) << 32)
-        | (((bytes[16]) as u64) << 24)
-        | (((bytes[17]) as u64) << 16)
-        | (((bytes[18]) as u64) << 8)
-        | ((bytes[19]) as u64);
-    values[4] = (((bytes[20]) as u64) << 32)
-        | (((bytes[21]) as u64) << 24)
-        | (((bytes[22]) as u64) << 16)
-        | (((bytes[23]) as u64) << 8)
-        | ((bytes[24]) as u64);
-    values[5] = (((bytes[25]) as u64) << 32)
-        | (((bytes[26]) as u64) << 24)
-        | (((bytes[27]) as u64) << 16)
-        | (((bytes[28]) as u64) << 8)
-        | ((bytes[29]) as u64);
-    values[6] = (((bytes[30]) as u64) << 32)
-        | (((bytes[31]) as u64) << 24)
-        | (((bytes[32]) as u64) << 16)
-        | (((bytes[33]) as u64) << 8)
-        | ((bytes[34]) as u64);
-    values[7] = (((bytes[35]) as u64) << 32)
-        | (((bytes[36]) as u64) << 24)
-        | (((bytes[37]) as u64) << 16)
-        | (((bytes[38]) as u64) << 8)
-        | ((bytes[39]) as u64);
+    values[0] = ((bytes[0] as u64) << 32)
+        | ((bytes[1] as u64) << 24)
+        | ((bytes[2] as u64) << 16)
+        | ((bytes[3] as u64) << 8)
+        | (bytes[4] as u64);
+    values[1] = ((bytes[5] as u64) << 32)
+        | ((bytes[6] as u64) << 24)
+        | ((bytes[7] as u64) << 16)
+        | ((bytes[8] as u64) << 8)
+        | (bytes[9] as u64);
+    values[2] = ((bytes[10] as u64) << 32)
+        | ((bytes[11] as u64) << 24)
+        | ((bytes[12] as u64) << 16)
+        | ((bytes[13] as u64) << 8)
+        | (bytes[14] as u64);
+    values[3] = ((bytes[15] as u64) << 32)
+        | ((bytes[16] as u64) << 24)
+        | ((bytes[17] as u64) << 16)
+        | ((bytes[18] as u64) << 8)
+        | (bytes[19] as u64);
+    values[4] = ((bytes[20] as u64) << 32)
+        | ((bytes[21] as u64) << 24)
+        | ((bytes[22] as u64) << 16)
+        | ((bytes[23] as u64) << 8)
+        | (bytes[24] as u64);
+    values[5] = ((bytes[25] as u64) << 32)
+        | ((bytes[26] as u64) << 24)
+        | ((bytes[27] as u64) << 16)
+        | ((bytes[28] as u64) << 8)
+        | (bytes[29] as u64);
+    values[6] = ((bytes[30] as u64) << 32)
+        | ((bytes[31] as u64) << 24)
+        | ((bytes[32] as u64) << 16)
+        | ((bytes[33] as u64) << 8)
+        | (bytes[34] as u64);
+    values[7] = ((bytes[35] as u64) << 32)
+        | ((bytes[36] as u64) << 24)
+        | ((bytes[37] as u64) << 16)
+        | ((bytes[38] as u64) << 8)
+        | (bytes[39] as u64);
 }
 
 #[inline]
 fn unpack_bits_41(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 33)
-        | (((bytes[1]) as u64) << 25)
-        | (((bytes[2]) as u64) << 17)
-        | (((bytes[3]) as u64) << 9)
-        | (((bytes[4]) as u64) << 1)
+    values[0] = ((bytes[0] as u64) << 33)
+        | ((bytes[1] as u64) << 25)
+        | ((bytes[2] as u64) << 17)
+        | ((bytes[3] as u64) << 9)
+        | ((bytes[4] as u64) << 1)
         | (((bytes[5] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[5]) & 0x7f) as u64) << 34)
-        | (((bytes[6]) as u64) << 26)
-        | (((bytes[7]) as u64) << 18)
-        | (((bytes[8]) as u64) << 10)
-        | (((bytes[9]) as u64) << 2)
+        | ((bytes[6] as u64) << 26)
+        | ((bytes[7] as u64) << 18)
+        | ((bytes[8] as u64) << 10)
+        | ((bytes[9] as u64) << 2)
         | (((bytes[10] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[10]) & 0x3f) as u64) << 35)
-        | (((bytes[11]) as u64) << 27)
-        | (((bytes[12]) as u64) << 19)
-        | (((bytes[13]) as u64) << 11)
-        | (((bytes[14]) as u64) << 3)
+        | ((bytes[11] as u64) << 27)
+        | ((bytes[12] as u64) << 19)
+        | ((bytes[13] as u64) << 11)
+        | ((bytes[14] as u64) << 3)
         | (((bytes[15] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[15]) & 0x1f) as u64) << 36)
-        | (((bytes[16]) as u64) << 28)
-        | (((bytes[17]) as u64) << 20)
-        | (((bytes[18]) as u64) << 12)
-        | (((bytes[19]) as u64) << 4)
+        | ((bytes[16] as u64) << 28)
+        | ((bytes[17] as u64) << 20)
+        | ((bytes[18] as u64) << 12)
+        | ((bytes[19] as u64) << 4)
         | (((bytes[20] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[20]) & 0xf) as u64) << 37)
-        | (((bytes[21]) as u64) << 29)
-        | (((bytes[22]) as u64) << 21)
-        | (((bytes[23]) as u64) << 13)
-        | (((bytes[24]) as u64) << 5)
+        | ((bytes[21] as u64) << 29)
+        | ((bytes[22] as u64) << 21)
+        | ((bytes[23] as u64) << 13)
+        | ((bytes[24] as u64) << 5)
         | (((bytes[25] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[25]) & 0x7) as u64) << 38)
-        | (((bytes[26]) as u64) << 30)
-        | (((bytes[27]) as u64) << 22)
-        | (((bytes[28]) as u64) << 14)
-        | (((bytes[29]) as u64) << 6)
+        | ((bytes[26] as u64) << 30)
+        | ((bytes[27] as u64) << 22)
+        | ((bytes[28] as u64) << 14)
+        | ((bytes[29] as u64) << 6)
         | (((bytes[30] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[30]) & 0x3) as u64) << 39)
-        | (((bytes[31]) as u64) << 31)
-        | (((bytes[32]) as u64) << 23)
-        | (((bytes[33]) as u64) << 15)
-        | (((bytes[34]) as u64) << 7)
+        | ((bytes[31] as u64) << 31)
+        | ((bytes[32] as u64) << 23)
+        | ((bytes[33] as u64) << 15)
+        | ((bytes[34] as u64) << 7)
         | (((bytes[35] >> 1) & 0x7f) as u64);
     values[7] = ((((bytes[35]) & 0x1) as u64) << 40)
-        | (((bytes[36]) as u64) << 32)
-        | (((bytes[37]) as u64) << 24)
-        | (((bytes[38]) as u64) << 16)
-        | (((bytes[39]) as u64) << 8)
-        | ((bytes[40]) as u64);
+        | ((bytes[36] as u64) << 32)
+        | ((bytes[37] as u64) << 24)
+        | ((bytes[38] as u64) << 16)
+        | ((bytes[39] as u64) << 8)
+        | (bytes[40] as u64);
 }
 
 #[inline]
 fn unpack_bits_42(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 34)
-        | (((bytes[1]) as u64) << 26)
-        | (((bytes[2]) as u64) << 18)
-        | (((bytes[3]) as u64) << 10)
-        | (((bytes[4]) as u64) << 2)
+    values[0] = ((bytes[0] as u64) << 34)
+        | ((bytes[1] as u64) << 26)
+        | ((bytes[2] as u64) << 18)
+        | ((bytes[3] as u64) << 10)
+        | ((bytes[4] as u64) << 2)
         | (((bytes[5] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[5]) & 0x3f) as u64) << 36)
-        | (((bytes[6]) as u64) << 28)
-        | (((bytes[7]) as u64) << 20)
-        | (((bytes[8]) as u64) << 12)
-        | (((bytes[9]) as u64) << 4)
+        | ((bytes[6] as u64) << 28)
+        | ((bytes[7] as u64) << 20)
+        | ((bytes[8] as u64) << 12)
+        | ((bytes[9] as u64) << 4)
         | (((bytes[10] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[10]) & 0xf) as u64) << 38)
-        | (((bytes[11]) as u64) << 30)
-        | (((bytes[12]) as u64) << 22)
-        | (((bytes[13]) as u64) << 14)
-        | (((bytes[14]) as u64) << 6)
+        | ((bytes[11] as u64) << 30)
+        | ((bytes[12] as u64) << 22)
+        | ((bytes[13] as u64) << 14)
+        | ((bytes[14] as u64) << 6)
         | (((bytes[15] >> 2) & 0x3f) as u64);
     values[3] = ((((bytes[15]) & 0x3) as u64) << 40)
-        | (((bytes[16]) as u64) << 32)
-        | (((bytes[17]) as u64) << 24)
-        | (((bytes[18]) as u64) << 16)
-        | (((bytes[19]) as u64) << 8)
-        | ((bytes[20]) as u64);
-    values[4] = (((bytes[21]) as u64) << 34)
-        | (((bytes[22]) as u64) << 26)
-        | (((bytes[23]) as u64) << 18)
-        | (((bytes[24]) as u64) << 10)
-        | (((bytes[25]) as u64) << 2)
+        | ((bytes[16] as u64) << 32)
+        | ((bytes[17] as u64) << 24)
+        | ((bytes[18] as u64) << 16)
+        | ((bytes[19] as u64) << 8)
+        | (bytes[20] as u64);
+    values[4] = ((bytes[21] as u64) << 34)
+        | ((bytes[22] as u64) << 26)
+        | ((bytes[23] as u64) << 18)
+        | ((bytes[24] as u64) << 10)
+        | ((bytes[25] as u64) << 2)
         | (((bytes[26] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[26]) & 0x3f) as u64) << 36)
-        | (((bytes[27]) as u64) << 28)
-        | (((bytes[28]) as u64) << 20)
-        | (((bytes[29]) as u64) << 12)
-        | (((bytes[30]) as u64) << 4)
+        | ((bytes[27] as u64) << 28)
+        | ((bytes[28] as u64) << 20)
+        | ((bytes[29] as u64) << 12)
+        | ((bytes[30] as u64) << 4)
         | (((bytes[31] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[31]) & 0xf) as u64) << 38)
-        | (((bytes[32]) as u64) << 30)
-        | (((bytes[33]) as u64) << 22)
-        | (((bytes[34]) as u64) << 14)
-        | (((bytes[35]) as u64) << 6)
+        | ((bytes[32] as u64) << 30)
+        | ((bytes[33] as u64) << 22)
+        | ((bytes[34] as u64) << 14)
+        | ((bytes[35] as u64) << 6)
         | (((bytes[36] >> 2) & 0x3f) as u64);
     values[7] = ((((bytes[36]) & 0x3) as u64) << 40)
-        | (((bytes[37]) as u64) << 32)
-        | (((bytes[38]) as u64) << 24)
-        | (((bytes[39]) as u64) << 16)
-        | (((bytes[40]) as u64) << 8)
-        | ((bytes[41]) as u64);
+        | ((bytes[37] as u64) << 32)
+        | ((bytes[38] as u64) << 24)
+        | ((bytes[39] as u64) << 16)
+        | ((bytes[40] as u64) << 8)
+        | (bytes[41] as u64);
 }
 
 #[inline]
 fn unpack_bits_43(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 35)
-        | (((bytes[1]) as u64) << 27)
-        | (((bytes[2]) as u64) << 19)
-        | (((bytes[3]) as u64) << 11)
-        | (((bytes[4]) as u64) << 3)
+    values[0] = ((bytes[0] as u64) << 35)
+        | ((bytes[1] as u64) << 27)
+        | ((bytes[2] as u64) << 19)
+        | ((bytes[3] as u64) << 11)
+        | ((bytes[4] as u64) << 3)
         | (((bytes[5] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[5]) & 0x1f) as u64) << 38)
-        | (((bytes[6]) as u64) << 30)
-        | (((bytes[7]) as u64) << 22)
-        | (((bytes[8]) as u64) << 14)
-        | (((bytes[9]) as u64) << 6)
+        | ((bytes[6] as u64) << 30)
+        | ((bytes[7] as u64) << 22)
+        | ((bytes[8] as u64) << 14)
+        | ((bytes[9] as u64) << 6)
         | (((bytes[10] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[10]) & 0x3) as u64) << 41)
-        | (((bytes[11]) as u64) << 33)
-        | (((bytes[12]) as u64) << 25)
-        | (((bytes[13]) as u64) << 17)
-        | (((bytes[14]) as u64) << 9)
-        | (((bytes[15]) as u64) << 1)
+        | ((bytes[11] as u64) << 33)
+        | ((bytes[12] as u64) << 25)
+        | ((bytes[13] as u64) << 17)
+        | ((bytes[14] as u64) << 9)
+        | ((bytes[15] as u64) << 1)
         | (((bytes[16] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[16]) & 0x7f) as u64) << 36)
-        | (((bytes[17]) as u64) << 28)
-        | (((bytes[18]) as u64) << 20)
-        | (((bytes[19]) as u64) << 12)
-        | (((bytes[20]) as u64) << 4)
+        | ((bytes[17] as u64) << 28)
+        | ((bytes[18] as u64) << 20)
+        | ((bytes[19] as u64) << 12)
+        | ((bytes[20] as u64) << 4)
         | (((bytes[21] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[21]) & 0xf) as u64) << 39)
-        | (((bytes[22]) as u64) << 31)
-        | (((bytes[23]) as u64) << 23)
-        | (((bytes[24]) as u64) << 15)
-        | (((bytes[25]) as u64) << 7)
+        | ((bytes[22] as u64) << 31)
+        | ((bytes[23] as u64) << 23)
+        | ((bytes[24] as u64) << 15)
+        | ((bytes[25] as u64) << 7)
         | (((bytes[26] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[26]) & 0x1) as u64) << 42)
-        | (((bytes[27]) as u64) << 34)
-        | (((bytes[28]) as u64) << 26)
-        | (((bytes[29]) as u64) << 18)
-        | (((bytes[30]) as u64) << 10)
-        | (((bytes[31]) as u64) << 2)
+        | ((bytes[27] as u64) << 34)
+        | ((bytes[28] as u64) << 26)
+        | ((bytes[29] as u64) << 18)
+        | ((bytes[30] as u64) << 10)
+        | ((bytes[31] as u64) << 2)
         | (((bytes[32] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[32]) & 0x3f) as u64) << 37)
-        | (((bytes[33]) as u64) << 29)
-        | (((bytes[34]) as u64) << 21)
-        | (((bytes[35]) as u64) << 13)
-        | (((bytes[36]) as u64) << 5)
+        | ((bytes[33] as u64) << 29)
+        | ((bytes[34] as u64) << 21)
+        | ((bytes[35] as u64) << 13)
+        | ((bytes[36] as u64) << 5)
         | (((bytes[37] >> 3) & 0x1f) as u64);
     values[7] = ((((bytes[37]) & 0x7) as u64) << 40)
-        | (((bytes[38]) as u64) << 32)
-        | (((bytes[39]) as u64) << 24)
-        | (((bytes[40]) as u64) << 16)
-        | (((bytes[41]) as u64) << 8)
-        | ((bytes[42]) as u64);
+        | ((bytes[38] as u64) << 32)
+        | ((bytes[39] as u64) << 24)
+        | ((bytes[40] as u64) << 16)
+        | ((bytes[41] as u64) << 8)
+        | (bytes[42] as u64);
 }
 
 #[inline]
 fn unpack_bits_44(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 36)
-        | (((bytes[1]) as u64) << 28)
-        | (((bytes[2]) as u64) << 20)
-        | (((bytes[3]) as u64) << 12)
-        | (((bytes[4]) as u64) << 4)
+    values[0] = ((bytes[0] as u64) << 36)
+        | ((bytes[1] as u64) << 28)
+        | ((bytes[2] as u64) << 20)
+        | ((bytes[3] as u64) << 12)
+        | ((bytes[4] as u64) << 4)
         | (((bytes[5] >> 4) & 0xf) as u64);
     values[1] = ((((bytes[5]) & 0xf) as u64) << 40)
-        | (((bytes[6]) as u64) << 32)
-        | (((bytes[7]) as u64) << 24)
-        | (((bytes[8]) as u64) << 16)
-        | (((bytes[9]) as u64) << 8)
-        | ((bytes[10]) as u64);
-    values[2] = (((bytes[11]) as u64) << 36)
-        | (((bytes[12]) as u64) << 28)
-        | (((bytes[13]) as u64) << 20)
-        | (((bytes[14]) as u64) << 12)
-        | (((bytes[15]) as u64) << 4)
+        | ((bytes[6] as u64) << 32)
+        | ((bytes[7] as u64) << 24)
+        | ((bytes[8] as u64) << 16)
+        | ((bytes[9] as u64) << 8)
+        | (bytes[10] as u64);
+    values[2] = ((bytes[11] as u64) << 36)
+        | ((bytes[12] as u64) << 28)
+        | ((bytes[13] as u64) << 20)
+        | ((bytes[14] as u64) << 12)
+        | ((bytes[15] as u64) << 4)
         | (((bytes[16] >> 4) & 0xf) as u64);
     values[3] = ((((bytes[16]) & 0xf) as u64) << 40)
-        | (((bytes[17]) as u64) << 32)
-        | (((bytes[18]) as u64) << 24)
-        | (((bytes[19]) as u64) << 16)
-        | (((bytes[20]) as u64) << 8)
-        | ((bytes[21]) as u64);
-    values[4] = (((bytes[22]) as u64) << 36)
-        | (((bytes[23]) as u64) << 28)
-        | (((bytes[24]) as u64) << 20)
-        | (((bytes[25]) as u64) << 12)
-        | (((bytes[26]) as u64) << 4)
+        | ((bytes[17] as u64) << 32)
+        | ((bytes[18] as u64) << 24)
+        | ((bytes[19] as u64) << 16)
+        | ((bytes[20] as u64) << 8)
+        | (bytes[21] as u64);
+    values[4] = ((bytes[22] as u64) << 36)
+        | ((bytes[23] as u64) << 28)
+        | ((bytes[24] as u64) << 20)
+        | ((bytes[25] as u64) << 12)
+        | ((bytes[26] as u64) << 4)
         | (((bytes[27] >> 4) & 0xf) as u64);
     values[5] = ((((bytes[27]) & 0xf) as u64) << 40)
-        | (((bytes[28]) as u64) << 32)
-        | (((bytes[29]) as u64) << 24)
-        | (((bytes[30]) as u64) << 16)
-        | (((bytes[31]) as u64) << 8)
-        | ((bytes[32]) as u64);
-    values[6] = (((bytes[33]) as u64) << 36)
-        | (((bytes[34]) as u64) << 28)
-        | (((bytes[35]) as u64) << 20)
-        | (((bytes[36]) as u64) << 12)
-        | (((bytes[37]) as u64) << 4)
+        | ((bytes[28] as u64) << 32)
+        | ((bytes[29] as u64) << 24)
+        | ((bytes[30] as u64) << 16)
+        | ((bytes[31] as u64) << 8)
+        | (bytes[32] as u64);
+    values[6] = ((bytes[33] as u64) << 36)
+        | ((bytes[34] as u64) << 28)
+        | ((bytes[35] as u64) << 20)
+        | ((bytes[36] as u64) << 12)
+        | ((bytes[37] as u64) << 4)
         | (((bytes[38] >> 4) & 0xf) as u64);
     values[7] = ((((bytes[38]) & 0xf) as u64) << 40)
-        | (((bytes[39]) as u64) << 32)
-        | (((bytes[40]) as u64) << 24)
-        | (((bytes[41]) as u64) << 16)
-        | (((bytes[42]) as u64) << 8)
-        | ((bytes[43]) as u64);
+        | ((bytes[39] as u64) << 32)
+        | ((bytes[40] as u64) << 24)
+        | ((bytes[41] as u64) << 16)
+        | ((bytes[42] as u64) << 8)
+        | (bytes[43] as u64);
 }
 
 #[inline]
 fn unpack_bits_45(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 37)
-        | (((bytes[1]) as u64) << 29)
-        | (((bytes[2]) as u64) << 21)
-        | (((bytes[3]) as u64) << 13)
-        | (((bytes[4]) as u64) << 5)
+    values[0] = ((bytes[0] as u64) << 37)
+        | ((bytes[1] as u64) << 29)
+        | ((bytes[2] as u64) << 21)
+        | ((bytes[3] as u64) << 13)
+        | ((bytes[4] as u64) << 5)
         | (((bytes[5] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[5]) & 0x7) as u64) << 42)
-        | (((bytes[6]) as u64) << 34)
-        | (((bytes[7]) as u64) << 26)
-        | (((bytes[8]) as u64) << 18)
-        | (((bytes[9]) as u64) << 10)
-        | (((bytes[10]) as u64) << 2)
+        | ((bytes[6] as u64) << 34)
+        | ((bytes[7] as u64) << 26)
+        | ((bytes[8] as u64) << 18)
+        | ((bytes[9] as u64) << 10)
+        | ((bytes[10] as u64) << 2)
         | (((bytes[11] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[11]) & 0x3f) as u64) << 39)
-        | (((bytes[12]) as u64) << 31)
-        | (((bytes[13]) as u64) << 23)
-        | (((bytes[14]) as u64) << 15)
-        | (((bytes[15]) as u64) << 7)
+        | ((bytes[12] as u64) << 31)
+        | ((bytes[13] as u64) << 23)
+        | ((bytes[14] as u64) << 15)
+        | ((bytes[15] as u64) << 7)
         | (((bytes[16] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[16]) & 0x1) as u64) << 44)
-        | (((bytes[17]) as u64) << 36)
-        | (((bytes[18]) as u64) << 28)
-        | (((bytes[19]) as u64) << 20)
-        | (((bytes[20]) as u64) << 12)
-        | (((bytes[21]) as u64) << 4)
+        | ((bytes[17] as u64) << 36)
+        | ((bytes[18] as u64) << 28)
+        | ((bytes[19] as u64) << 20)
+        | ((bytes[20] as u64) << 12)
+        | ((bytes[21] as u64) << 4)
         | (((bytes[22] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[22]) & 0xf) as u64) << 41)
-        | (((bytes[23]) as u64) << 33)
-        | (((bytes[24]) as u64) << 25)
-        | (((bytes[25]) as u64) << 17)
-        | (((bytes[26]) as u64) << 9)
-        | (((bytes[27]) as u64) << 1)
+        | ((bytes[23] as u64) << 33)
+        | ((bytes[24] as u64) << 25)
+        | ((bytes[25] as u64) << 17)
+        | ((bytes[26] as u64) << 9)
+        | ((bytes[27] as u64) << 1)
         | (((bytes[28] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[28]) & 0x7f) as u64) << 38)
-        | (((bytes[29]) as u64) << 30)
-        | (((bytes[30]) as u64) << 22)
-        | (((bytes[31]) as u64) << 14)
-        | (((bytes[32]) as u64) << 6)
+        | ((bytes[29] as u64) << 30)
+        | ((bytes[30] as u64) << 22)
+        | ((bytes[31] as u64) << 14)
+        | ((bytes[32] as u64) << 6)
         | (((bytes[33] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[33]) & 0x3) as u64) << 43)
-        | (((bytes[34]) as u64) << 35)
-        | (((bytes[35]) as u64) << 27)
-        | (((bytes[36]) as u64) << 19)
-        | (((bytes[37]) as u64) << 11)
-        | (((bytes[38]) as u64) << 3)
+        | ((bytes[34] as u64) << 35)
+        | ((bytes[35] as u64) << 27)
+        | ((bytes[36] as u64) << 19)
+        | ((bytes[37] as u64) << 11)
+        | ((bytes[38] as u64) << 3)
         | (((bytes[39] >> 5) & 0x7) as u64);
     values[7] = ((((bytes[39]) & 0x1f) as u64) << 40)
-        | (((bytes[40]) as u64) << 32)
-        | (((bytes[41]) as u64) << 24)
-        | (((bytes[42]) as u64) << 16)
-        | (((bytes[43]) as u64) << 8)
-        | ((bytes[44]) as u64);
+        | ((bytes[40] as u64) << 32)
+        | ((bytes[41] as u64) << 24)
+        | ((bytes[42] as u64) << 16)
+        | ((bytes[43] as u64) << 8)
+        | (bytes[44] as u64);
 }
 
 #[inline]
 fn unpack_bits_46(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 38)
-        | (((bytes[1]) as u64) << 30)
-        | (((bytes[2]) as u64) << 22)
-        | (((bytes[3]) as u64) << 14)
-        | (((bytes[4]) as u64) << 6)
+    values[0] = ((bytes[0] as u64) << 38)
+        | ((bytes[1] as u64) << 30)
+        | ((bytes[2] as u64) << 22)
+        | ((bytes[3] as u64) << 14)
+        | ((bytes[4] as u64) << 6)
         | (((bytes[5] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[5]) & 0x3) as u64) << 44)
-        | (((bytes[6]) as u64) << 36)
-        | (((bytes[7]) as u64) << 28)
-        | (((bytes[8]) as u64) << 20)
-        | (((bytes[9]) as u64) << 12)
-        | (((bytes[10]) as u64) << 4)
+        | ((bytes[6] as u64) << 36)
+        | ((bytes[7] as u64) << 28)
+        | ((bytes[8] as u64) << 20)
+        | ((bytes[9] as u64) << 12)
+        | ((bytes[10] as u64) << 4)
         | (((bytes[11] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[11]) & 0xf) as u64) << 42)
-        | (((bytes[12]) as u64) << 34)
-        | (((bytes[13]) as u64) << 26)
-        | (((bytes[14]) as u64) << 18)
-        | (((bytes[15]) as u64) << 10)
-        | (((bytes[16]) as u64) << 2)
+        | ((bytes[12] as u64) << 34)
+        | ((bytes[13] as u64) << 26)
+        | ((bytes[14] as u64) << 18)
+        | ((bytes[15] as u64) << 10)
+        | ((bytes[16] as u64) << 2)
         | (((bytes[17] >> 6) & 0x3) as u64);
     values[3] = ((((bytes[17]) & 0x3f) as u64) << 40)
-        | (((bytes[18]) as u64) << 32)
-        | (((bytes[19]) as u64) << 24)
-        | (((bytes[20]) as u64) << 16)
-        | (((bytes[21]) as u64) << 8)
-        | ((bytes[22]) as u64);
-    values[4] = (((bytes[23]) as u64) << 38)
-        | (((bytes[24]) as u64) << 30)
-        | (((bytes[25]) as u64) << 22)
-        | (((bytes[26]) as u64) << 14)
-        | (((bytes[27]) as u64) << 6)
+        | ((bytes[18] as u64) << 32)
+        | ((bytes[19] as u64) << 24)
+        | ((bytes[20] as u64) << 16)
+        | ((bytes[21] as u64) << 8)
+        | (bytes[22] as u64);
+    values[4] = ((bytes[23] as u64) << 38)
+        | ((bytes[24] as u64) << 30)
+        | ((bytes[25] as u64) << 22)
+        | ((bytes[26] as u64) << 14)
+        | ((bytes[27] as u64) << 6)
         | (((bytes[28] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[28]) & 0x3) as u64) << 44)
-        | (((bytes[29]) as u64) << 36)
-        | (((bytes[30]) as u64) << 28)
-        | (((bytes[31]) as u64) << 20)
-        | (((bytes[32]) as u64) << 12)
-        | (((bytes[33]) as u64) << 4)
+        | ((bytes[29] as u64) << 36)
+        | ((bytes[30] as u64) << 28)
+        | ((bytes[31] as u64) << 20)
+        | ((bytes[32] as u64) << 12)
+        | ((bytes[33] as u64) << 4)
         | (((bytes[34] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[34]) & 0xf) as u64) << 42)
-        | (((bytes[35]) as u64) << 34)
-        | (((bytes[36]) as u64) << 26)
-        | (((bytes[37]) as u64) << 18)
-        | (((bytes[38]) as u64) << 10)
-        | (((bytes[39]) as u64) << 2)
+        | ((bytes[35] as u64) << 34)
+        | ((bytes[36] as u64) << 26)
+        | ((bytes[37] as u64) << 18)
+        | ((bytes[38] as u64) << 10)
+        | ((bytes[39] as u64) << 2)
         | (((bytes[40] >> 6) & 0x3) as u64);
     values[7] = ((((bytes[40]) & 0x3f) as u64) << 40)
-        | (((bytes[41]) as u64) << 32)
-        | (((bytes[42]) as u64) << 24)
-        | (((bytes[43]) as u64) << 16)
-        | (((bytes[44]) as u64) << 8)
-        | ((bytes[45]) as u64);
+        | ((bytes[41] as u64) << 32)
+        | ((bytes[42] as u64) << 24)
+        | ((bytes[43] as u64) << 16)
+        | ((bytes[44] as u64) << 8)
+        | (bytes[45] as u64);
 }
 
 #[inline]
 fn unpack_bits_47(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 39)
-        | (((bytes[1]) as u64) << 31)
-        | (((bytes[2]) as u64) << 23)
-        | (((bytes[3]) as u64) << 15)
-        | (((bytes[4]) as u64) << 7)
+    values[0] = ((bytes[0] as u64) << 39)
+        | ((bytes[1] as u64) << 31)
+        | ((bytes[2] as u64) << 23)
+        | ((bytes[3] as u64) << 15)
+        | ((bytes[4] as u64) << 7)
         | (((bytes[5] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[5]) & 0x1) as u64) << 46)
-        | (((bytes[6]) as u64) << 38)
-        | (((bytes[7]) as u64) << 30)
-        | (((bytes[8]) as u64) << 22)
-        | (((bytes[9]) as u64) << 14)
-        | (((bytes[10]) as u64) << 6)
+        | ((bytes[6] as u64) << 38)
+        | ((bytes[7] as u64) << 30)
+        | ((bytes[8] as u64) << 22)
+        | ((bytes[9] as u64) << 14)
+        | ((bytes[10] as u64) << 6)
         | (((bytes[11] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[11]) & 0x3) as u64) << 45)
-        | (((bytes[12]) as u64) << 37)
-        | (((bytes[13]) as u64) << 29)
-        | (((bytes[14]) as u64) << 21)
-        | (((bytes[15]) as u64) << 13)
-        | (((bytes[16]) as u64) << 5)
+        | ((bytes[12] as u64) << 37)
+        | ((bytes[13] as u64) << 29)
+        | ((bytes[14] as u64) << 21)
+        | ((bytes[15] as u64) << 13)
+        | ((bytes[16] as u64) << 5)
         | (((bytes[17] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[17]) & 0x7) as u64) << 44)
-        | (((bytes[18]) as u64) << 36)
-        | (((bytes[19]) as u64) << 28)
-        | (((bytes[20]) as u64) << 20)
-        | (((bytes[21]) as u64) << 12)
-        | (((bytes[22]) as u64) << 4)
+        | ((bytes[18] as u64) << 36)
+        | ((bytes[19] as u64) << 28)
+        | ((bytes[20] as u64) << 20)
+        | ((bytes[21] as u64) << 12)
+        | ((bytes[22] as u64) << 4)
         | (((bytes[23] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[23]) & 0xf) as u64) << 43)
-        | (((bytes[24]) as u64) << 35)
-        | (((bytes[25]) as u64) << 27)
-        | (((bytes[26]) as u64) << 19)
-        | (((bytes[27]) as u64) << 11)
-        | (((bytes[28]) as u64) << 3)
+        | ((bytes[24] as u64) << 35)
+        | ((bytes[25] as u64) << 27)
+        | ((bytes[26] as u64) << 19)
+        | ((bytes[27] as u64) << 11)
+        | ((bytes[28] as u64) << 3)
         | (((bytes[29] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[29]) & 0x1f) as u64) << 42)
-        | (((bytes[30]) as u64) << 34)
-        | (((bytes[31]) as u64) << 26)
-        | (((bytes[32]) as u64) << 18)
-        | (((bytes[33]) as u64) << 10)
-        | (((bytes[34]) as u64) << 2)
+        | ((bytes[30] as u64) << 34)
+        | ((bytes[31] as u64) << 26)
+        | ((bytes[32] as u64) << 18)
+        | ((bytes[33] as u64) << 10)
+        | ((bytes[34] as u64) << 2)
         | (((bytes[35] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[35]) & 0x3f) as u64) << 41)
-        | (((bytes[36]) as u64) << 33)
-        | (((bytes[37]) as u64) << 25)
-        | (((bytes[38]) as u64) << 17)
-        | (((bytes[39]) as u64) << 9)
-        | (((bytes[40]) as u64) << 1)
+        | ((bytes[36] as u64) << 33)
+        | ((bytes[37] as u64) << 25)
+        | ((bytes[38] as u64) << 17)
+        | ((bytes[39] as u64) << 9)
+        | ((bytes[40] as u64) << 1)
         | (((bytes[41] >> 7) & 0x1) as u64);
     values[7] = ((((bytes[41]) & 0x7f) as u64) << 40)
-        | (((bytes[42]) as u64) << 32)
-        | (((bytes[43]) as u64) << 24)
-        | (((bytes[44]) as u64) << 16)
-        | (((bytes[45]) as u64) << 8)
-        | ((bytes[46]) as u64);
+        | ((bytes[42] as u64) << 32)
+        | ((bytes[43] as u64) << 24)
+        | ((bytes[44] as u64) << 16)
+        | ((bytes[45] as u64) << 8)
+        | (bytes[46] as u64);
 }
 
 #[inline]
 fn unpack_bits_48(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 40)
-        | (((bytes[1]) as u64) << 32)
-        | (((bytes[2]) as u64) << 24)
-        | (((bytes[3]) as u64) << 16)
-        | (((bytes[4]) as u64) << 8)
-        | ((bytes[5]) as u64);
-    values[1] = (((bytes[6]) as u64) << 40)
-        | (((bytes[7]) as u64) << 32)
-        | (((bytes[8]) as u64) << 24)
-        | (((bytes[9]) as u64) << 16)
-        | (((bytes[10]) as u64) << 8)
-        | ((bytes[11]) as u64);
-    values[2] = (((bytes[12]) as u64) << 40)
-        | (((bytes[13]) as u64) << 32)
-        | (((bytes[14]) as u64) << 24)
-        | (((bytes[15]) as u64) << 16)
-        | (((bytes[16]) as u64) << 8)
-        | ((bytes[17]) as u64);
-    values[3] = (((bytes[18]) as u64) << 40)
-        | (((bytes[19]) as u64) << 32)
-        | (((bytes[20]) as u64) << 24)
-        | (((bytes[21]) as u64) << 16)
-        | (((bytes[22]) as u64) << 8)
-        | ((bytes[23]) as u64);
-    values[4] = (((bytes[24]) as u64) << 40)
-        | (((bytes[25]) as u64) << 32)
-        | (((bytes[26]) as u64) << 24)
-        | (((bytes[27]) as u64) << 16)
-        | (((bytes[28]) as u64) << 8)
-        | ((bytes[29]) as u64);
-    values[5] = (((bytes[30]) as u64) << 40)
-        | (((bytes[31]) as u64) << 32)
-        | (((bytes[32]) as u64) << 24)
-        | (((bytes[33]) as u64) << 16)
-        | (((bytes[34]) as u64) << 8)
-        | ((bytes[35]) as u64);
-    values[6] = (((bytes[36]) as u64) << 40)
-        | (((bytes[37]) as u64) << 32)
-        | (((bytes[38]) as u64) << 24)
-        | (((bytes[39]) as u64) << 16)
-        | (((bytes[40]) as u64) << 8)
-        | ((bytes[41]) as u64);
-    values[7] = (((bytes[42]) as u64) << 40)
-        | (((bytes[43]) as u64) << 32)
-        | (((bytes[44]) as u64) << 24)
-        | (((bytes[45]) as u64) << 16)
-        | (((bytes[46]) as u64) << 8)
-        | ((bytes[47]) as u64);
+    values[0] = ((bytes[0] as u64) << 40)
+        | ((bytes[1] as u64) << 32)
+        | ((bytes[2] as u64) << 24)
+        | ((bytes[3] as u64) << 16)
+        | ((bytes[4] as u64) << 8)
+        | (bytes[5] as u64);
+    values[1] = ((bytes[6] as u64) << 40)
+        | ((bytes[7] as u64) << 32)
+        | ((bytes[8] as u64) << 24)
+        | ((bytes[9] as u64) << 16)
+        | ((bytes[10] as u64) << 8)
+        | (bytes[11] as u64);
+    values[2] = ((bytes[12] as u64) << 40)
+        | ((bytes[13] as u64) << 32)
+        | ((bytes[14] as u64) << 24)
+        | ((bytes[15] as u64) << 16)
+        | ((bytes[16] as u64) << 8)
+        | (bytes[17] as u64);
+    values[3] = ((bytes[18] as u64) << 40)
+        | ((bytes[19] as u64) << 32)
+        | ((bytes[20] as u64) << 24)
+        | ((bytes[21] as u64) << 16)
+        | ((bytes[22] as u64) << 8)
+        | (bytes[23] as u64);
+    values[4] = ((bytes[24] as u64) << 40)
+        | ((bytes[25] as u64) << 32)
+        | ((bytes[26] as u64) << 24)
+        | ((bytes[27] as u64) << 16)
+        | ((bytes[28] as u64) << 8)
+        | (bytes[29] as u64);
+    values[5] = ((bytes[30] as u64) << 40)
+        | ((bytes[31] as u64) << 32)
+        | ((bytes[32] as u64) << 24)
+        | ((bytes[33] as u64) << 16)
+        | ((bytes[34] as u64) << 8)
+        | (bytes[35] as u64);
+    values[6] = ((bytes[36] as u64) << 40)
+        | ((bytes[37] as u64) << 32)
+        | ((bytes[38] as u64) << 24)
+        | ((bytes[39] as u64) << 16)
+        | ((bytes[40] as u64) << 8)
+        | (bytes[41] as u64);
+    values[7] = ((bytes[42] as u64) << 40)
+        | ((bytes[43] as u64) << 32)
+        | ((bytes[44] as u64) << 24)
+        | ((bytes[45] as u64) << 16)
+        | ((bytes[46] as u64) << 8)
+        | (bytes[47] as u64);
 }
 
 #[inline]
 fn unpack_bits_49(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 41)
-        | (((bytes[1]) as u64) << 33)
-        | (((bytes[2]) as u64) << 25)
-        | (((bytes[3]) as u64) << 17)
-        | (((bytes[4]) as u64) << 9)
-        | (((bytes[5]) as u64) << 1)
+    values[0] = ((bytes[0] as u64) << 41)
+        | ((bytes[1] as u64) << 33)
+        | ((bytes[2] as u64) << 25)
+        | ((bytes[3] as u64) << 17)
+        | ((bytes[4] as u64) << 9)
+        | ((bytes[5] as u64) << 1)
         | (((bytes[6] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[6]) & 0x7f) as u64) << 42)
-        | (((bytes[7]) as u64) << 34)
-        | (((bytes[8]) as u64) << 26)
-        | (((bytes[9]) as u64) << 18)
-        | (((bytes[10]) as u64) << 10)
-        | (((bytes[11]) as u64) << 2)
+        | ((bytes[7] as u64) << 34)
+        | ((bytes[8] as u64) << 26)
+        | ((bytes[9] as u64) << 18)
+        | ((bytes[10] as u64) << 10)
+        | ((bytes[11] as u64) << 2)
         | (((bytes[12] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[12]) & 0x3f) as u64) << 43)
-        | (((bytes[13]) as u64) << 35)
-        | (((bytes[14]) as u64) << 27)
-        | (((bytes[15]) as u64) << 19)
-        | (((bytes[16]) as u64) << 11)
-        | (((bytes[17]) as u64) << 3)
+        | ((bytes[13] as u64) << 35)
+        | ((bytes[14] as u64) << 27)
+        | ((bytes[15] as u64) << 19)
+        | ((bytes[16] as u64) << 11)
+        | ((bytes[17] as u64) << 3)
         | (((bytes[18] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[18]) & 0x1f) as u64) << 44)
-        | (((bytes[19]) as u64) << 36)
-        | (((bytes[20]) as u64) << 28)
-        | (((bytes[21]) as u64) << 20)
-        | (((bytes[22]) as u64) << 12)
-        | (((bytes[23]) as u64) << 4)
+        | ((bytes[19] as u64) << 36)
+        | ((bytes[20] as u64) << 28)
+        | ((bytes[21] as u64) << 20)
+        | ((bytes[22] as u64) << 12)
+        | ((bytes[23] as u64) << 4)
         | (((bytes[24] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[24]) & 0xf) as u64) << 45)
-        | (((bytes[25]) as u64) << 37)
-        | (((bytes[26]) as u64) << 29)
-        | (((bytes[27]) as u64) << 21)
-        | (((bytes[28]) as u64) << 13)
-        | (((bytes[29]) as u64) << 5)
+        | ((bytes[25] as u64) << 37)
+        | ((bytes[26] as u64) << 29)
+        | ((bytes[27] as u64) << 21)
+        | ((bytes[28] as u64) << 13)
+        | ((bytes[29] as u64) << 5)
         | (((bytes[30] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[30]) & 0x7) as u64) << 46)
-        | (((bytes[31]) as u64) << 38)
-        | (((bytes[32]) as u64) << 30)
-        | (((bytes[33]) as u64) << 22)
-        | (((bytes[34]) as u64) << 14)
-        | (((bytes[35]) as u64) << 6)
+        | ((bytes[31] as u64) << 38)
+        | ((bytes[32] as u64) << 30)
+        | ((bytes[33] as u64) << 22)
+        | ((bytes[34] as u64) << 14)
+        | ((bytes[35] as u64) << 6)
         | (((bytes[36] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[36]) & 0x3) as u64) << 47)
-        | (((bytes[37]) as u64) << 39)
-        | (((bytes[38]) as u64) << 31)
-        | (((bytes[39]) as u64) << 23)
-        | (((bytes[40]) as u64) << 15)
-        | (((bytes[41]) as u64) << 7)
+        | ((bytes[37] as u64) << 39)
+        | ((bytes[38] as u64) << 31)
+        | ((bytes[39] as u64) << 23)
+        | ((bytes[40] as u64) << 15)
+        | ((bytes[41] as u64) << 7)
         | (((bytes[42] >> 1) & 0x7f) as u64);
     values[7] = ((((bytes[42]) & 0x1) as u64) << 48)
-        | (((bytes[43]) as u64) << 40)
-        | (((bytes[44]) as u64) << 32)
-        | (((bytes[45]) as u64) << 24)
-        | (((bytes[46]) as u64) << 16)
-        | (((bytes[47]) as u64) << 8)
-        | ((bytes[48]) as u64);
+        | ((bytes[43] as u64) << 40)
+        | ((bytes[44] as u64) << 32)
+        | ((bytes[45] as u64) << 24)
+        | ((bytes[46] as u64) << 16)
+        | ((bytes[47] as u64) << 8)
+        | (bytes[48] as u64);
 }
 
 #[inline]
 fn unpack_bits_50(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 42)
-        | (((bytes[1]) as u64) << 34)
-        | (((bytes[2]) as u64) << 26)
-        | (((bytes[3]) as u64) << 18)
-        | (((bytes[4]) as u64) << 10)
-        | (((bytes[5]) as u64) << 2)
+    values[0] = ((bytes[0] as u64) << 42)
+        | ((bytes[1] as u64) << 34)
+        | ((bytes[2] as u64) << 26)
+        | ((bytes[3] as u64) << 18)
+        | ((bytes[4] as u64) << 10)
+        | ((bytes[5] as u64) << 2)
         | (((bytes[6] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[6]) & 0x3f) as u64) << 44)
-        | (((bytes[7]) as u64) << 36)
-        | (((bytes[8]) as u64) << 28)
-        | (((bytes[9]) as u64) << 20)
-        | (((bytes[10]) as u64) << 12)
-        | (((bytes[11]) as u64) << 4)
+        | ((bytes[7] as u64) << 36)
+        | ((bytes[8] as u64) << 28)
+        | ((bytes[9] as u64) << 20)
+        | ((bytes[10] as u64) << 12)
+        | ((bytes[11] as u64) << 4)
         | (((bytes[12] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[12]) & 0xf) as u64) << 46)
-        | (((bytes[13]) as u64) << 38)
-        | (((bytes[14]) as u64) << 30)
-        | (((bytes[15]) as u64) << 22)
-        | (((bytes[16]) as u64) << 14)
-        | (((bytes[17]) as u64) << 6)
+        | ((bytes[13] as u64) << 38)
+        | ((bytes[14] as u64) << 30)
+        | ((bytes[15] as u64) << 22)
+        | ((bytes[16] as u64) << 14)
+        | ((bytes[17] as u64) << 6)
         | (((bytes[18] >> 2) & 0x3f) as u64);
     values[3] = ((((bytes[18]) & 0x3) as u64) << 48)
-        | (((bytes[19]) as u64) << 40)
-        | (((bytes[20]) as u64) << 32)
-        | (((bytes[21]) as u64) << 24)
-        | (((bytes[22]) as u64) << 16)
-        | (((bytes[23]) as u64) << 8)
-        | ((bytes[24]) as u64);
-    values[4] = (((bytes[25]) as u64) << 42)
-        | (((bytes[26]) as u64) << 34)
-        | (((bytes[27]) as u64) << 26)
-        | (((bytes[28]) as u64) << 18)
-        | (((bytes[29]) as u64) << 10)
-        | (((bytes[30]) as u64) << 2)
+        | ((bytes[19] as u64) << 40)
+        | ((bytes[20] as u64) << 32)
+        | ((bytes[21] as u64) << 24)
+        | ((bytes[22] as u64) << 16)
+        | ((bytes[23] as u64) << 8)
+        | (bytes[24] as u64);
+    values[4] = ((bytes[25] as u64) << 42)
+        | ((bytes[26] as u64) << 34)
+        | ((bytes[27] as u64) << 26)
+        | ((bytes[28] as u64) << 18)
+        | ((bytes[29] as u64) << 10)
+        | ((bytes[30] as u64) << 2)
         | (((bytes[31] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[31]) & 0x3f) as u64) << 44)
-        | (((bytes[32]) as u64) << 36)
-        | (((bytes[33]) as u64) << 28)
-        | (((bytes[34]) as u64) << 20)
-        | (((bytes[35]) as u64) << 12)
-        | (((bytes[36]) as u64) << 4)
+        | ((bytes[32] as u64) << 36)
+        | ((bytes[33] as u64) << 28)
+        | ((bytes[34] as u64) << 20)
+        | ((bytes[35] as u64) << 12)
+        | ((bytes[36] as u64) << 4)
         | (((bytes[37] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[37]) & 0xf) as u64) << 46)
-        | (((bytes[38]) as u64) << 38)
-        | (((bytes[39]) as u64) << 30)
-        | (((bytes[40]) as u64) << 22)
-        | (((bytes[41]) as u64) << 14)
-        | (((bytes[42]) as u64) << 6)
+        | ((bytes[38] as u64) << 38)
+        | ((bytes[39] as u64) << 30)
+        | ((bytes[40] as u64) << 22)
+        | ((bytes[41] as u64) << 14)
+        | ((bytes[42] as u64) << 6)
         | (((bytes[43] >> 2) & 0x3f) as u64);
     values[7] = ((((bytes[43]) & 0x3) as u64) << 48)
-        | (((bytes[44]) as u64) << 40)
-        | (((bytes[45]) as u64) << 32)
-        | (((bytes[46]) as u64) << 24)
-        | (((bytes[47]) as u64) << 16)
-        | (((bytes[48]) as u64) << 8)
-        | ((bytes[49]) as u64);
+        | ((bytes[44] as u64) << 40)
+        | ((bytes[45] as u64) << 32)
+        | ((bytes[46] as u64) << 24)
+        | ((bytes[47] as u64) << 16)
+        | ((bytes[48] as u64) << 8)
+        | (bytes[49] as u64);
 }
 
 #[inline]
 fn unpack_bits_51(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 43)
-        | (((bytes[1]) as u64) << 35)
-        | (((bytes[2]) as u64) << 27)
-        | (((bytes[3]) as u64) << 19)
-        | (((bytes[4]) as u64) << 11)
-        | (((bytes[5]) as u64) << 3)
+    values[0] = ((bytes[0] as u64) << 43)
+        | ((bytes[1] as u64) << 35)
+        | ((bytes[2] as u64) << 27)
+        | ((bytes[3] as u64) << 19)
+        | ((bytes[4] as u64) << 11)
+        | ((bytes[5] as u64) << 3)
         | (((bytes[6] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[6]) & 0x1f) as u64) << 46)
-        | (((bytes[7]) as u64) << 38)
-        | (((bytes[8]) as u64) << 30)
-        | (((bytes[9]) as u64) << 22)
-        | (((bytes[10]) as u64) << 14)
-        | (((bytes[11]) as u64) << 6)
+        | ((bytes[7] as u64) << 38)
+        | ((bytes[8] as u64) << 30)
+        | ((bytes[9] as u64) << 22)
+        | ((bytes[10] as u64) << 14)
+        | ((bytes[11] as u64) << 6)
         | (((bytes[12] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[12]) & 0x3) as u64) << 49)
-        | (((bytes[13]) as u64) << 41)
-        | (((bytes[14]) as u64) << 33)
-        | (((bytes[15]) as u64) << 25)
-        | (((bytes[16]) as u64) << 17)
-        | (((bytes[17]) as u64) << 9)
-        | (((bytes[18]) as u64) << 1)
+        | ((bytes[13] as u64) << 41)
+        | ((bytes[14] as u64) << 33)
+        | ((bytes[15] as u64) << 25)
+        | ((bytes[16] as u64) << 17)
+        | ((bytes[17] as u64) << 9)
+        | ((bytes[18] as u64) << 1)
         | (((bytes[19] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[19]) & 0x7f) as u64) << 44)
-        | (((bytes[20]) as u64) << 36)
-        | (((bytes[21]) as u64) << 28)
-        | (((bytes[22]) as u64) << 20)
-        | (((bytes[23]) as u64) << 12)
-        | (((bytes[24]) as u64) << 4)
+        | ((bytes[20] as u64) << 36)
+        | ((bytes[21] as u64) << 28)
+        | ((bytes[22] as u64) << 20)
+        | ((bytes[23] as u64) << 12)
+        | ((bytes[24] as u64) << 4)
         | (((bytes[25] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[25]) & 0xf) as u64) << 47)
-        | (((bytes[26]) as u64) << 39)
-        | (((bytes[27]) as u64) << 31)
-        | (((bytes[28]) as u64) << 23)
-        | (((bytes[29]) as u64) << 15)
-        | (((bytes[30]) as u64) << 7)
+        | ((bytes[26] as u64) << 39)
+        | ((bytes[27] as u64) << 31)
+        | ((bytes[28] as u64) << 23)
+        | ((bytes[29] as u64) << 15)
+        | ((bytes[30] as u64) << 7)
         | (((bytes[31] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[31]) & 0x1) as u64) << 50)
-        | (((bytes[32]) as u64) << 42)
-        | (((bytes[33]) as u64) << 34)
-        | (((bytes[34]) as u64) << 26)
-        | (((bytes[35]) as u64) << 18)
-        | (((bytes[36]) as u64) << 10)
-        | (((bytes[37]) as u64) << 2)
+        | ((bytes[32] as u64) << 42)
+        | ((bytes[33] as u64) << 34)
+        | ((bytes[34] as u64) << 26)
+        | ((bytes[35] as u64) << 18)
+        | ((bytes[36] as u64) << 10)
+        | ((bytes[37] as u64) << 2)
         | (((bytes[38] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[38]) & 0x3f) as u64) << 45)
-        | (((bytes[39]) as u64) << 37)
-        | (((bytes[40]) as u64) << 29)
-        | (((bytes[41]) as u64) << 21)
-        | (((bytes[42]) as u64) << 13)
-        | (((bytes[43]) as u64) << 5)
+        | ((bytes[39] as u64) << 37)
+        | ((bytes[40] as u64) << 29)
+        | ((bytes[41] as u64) << 21)
+        | ((bytes[42] as u64) << 13)
+        | ((bytes[43] as u64) << 5)
         | (((bytes[44] >> 3) & 0x1f) as u64);
     values[7] = ((((bytes[44]) & 0x7) as u64) << 48)
-        | (((bytes[45]) as u64) << 40)
-        | (((bytes[46]) as u64) << 32)
-        | (((bytes[47]) as u64) << 24)
-        | (((bytes[48]) as u64) << 16)
-        | (((bytes[49]) as u64) << 8)
-        | ((bytes[50]) as u64);
+        | ((bytes[45] as u64) << 40)
+        | ((bytes[46] as u64) << 32)
+        | ((bytes[47] as u64) << 24)
+        | ((bytes[48] as u64) << 16)
+        | ((bytes[49] as u64) << 8)
+        | (bytes[50] as u64);
 }
 
 #[inline]
 fn unpack_bits_52(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 44)
-        | (((bytes[1]) as u64) << 36)
-        | (((bytes[2]) as u64) << 28)
-        | (((bytes[3]) as u64) << 20)
-        | (((bytes[4]) as u64) << 12)
-        | (((bytes[5]) as u64) << 4)
+    values[0] = ((bytes[0] as u64) << 44)
+        | ((bytes[1] as u64) << 36)
+        | ((bytes[2] as u64) << 28)
+        | ((bytes[3] as u64) << 20)
+        | ((bytes[4] as u64) << 12)
+        | ((bytes[5] as u64) << 4)
         | (((bytes[6] >> 4) & 0xf) as u64);
     values[1] = ((((bytes[6]) & 0xf) as u64) << 48)
-        | (((bytes[7]) as u64) << 40)
-        | (((bytes[8]) as u64) << 32)
-        | (((bytes[9]) as u64) << 24)
-        | (((bytes[10]) as u64) << 16)
-        | (((bytes[11]) as u64) << 8)
-        | ((bytes[12]) as u64);
-    values[2] = (((bytes[13]) as u64) << 44)
-        | (((bytes[14]) as u64) << 36)
-        | (((bytes[15]) as u64) << 28)
-        | (((bytes[16]) as u64) << 20)
-        | (((bytes[17]) as u64) << 12)
-        | (((bytes[18]) as u64) << 4)
+        | ((bytes[7] as u64) << 40)
+        | ((bytes[8] as u64) << 32)
+        | ((bytes[9] as u64) << 24)
+        | ((bytes[10] as u64) << 16)
+        | ((bytes[11] as u64) << 8)
+        | (bytes[12] as u64);
+    values[2] = ((bytes[13] as u64) << 44)
+        | ((bytes[14] as u64) << 36)
+        | ((bytes[15] as u64) << 28)
+        | ((bytes[16] as u64) << 20)
+        | ((bytes[17] as u64) << 12)
+        | ((bytes[18] as u64) << 4)
         | (((bytes[19] >> 4) & 0xf) as u64);
     values[3] = ((((bytes[19]) & 0xf) as u64) << 48)
-        | (((bytes[20]) as u64) << 40)
-        | (((bytes[21]) as u64) << 32)
-        | (((bytes[22]) as u64) << 24)
-        | (((bytes[23]) as u64) << 16)
-        | (((bytes[24]) as u64) << 8)
-        | ((bytes[25]) as u64);
-    values[4] = (((bytes[26]) as u64) << 44)
-        | (((bytes[27]) as u64) << 36)
-        | (((bytes[28]) as u64) << 28)
-        | (((bytes[29]) as u64) << 20)
-        | (((bytes[30]) as u64) << 12)
-        | (((bytes[31]) as u64) << 4)
+        | ((bytes[20] as u64) << 40)
+        | ((bytes[21] as u64) << 32)
+        | ((bytes[22] as u64) << 24)
+        | ((bytes[23] as u64) << 16)
+        | ((bytes[24] as u64) << 8)
+        | (bytes[25] as u64);
+    values[4] = ((bytes[26] as u64) << 44)
+        | ((bytes[27] as u64) << 36)
+        | ((bytes[28] as u64) << 28)
+        | ((bytes[29] as u64) << 20)
+        | ((bytes[30] as u64) << 12)
+        | ((bytes[31] as u64) << 4)
         | (((bytes[32] >> 4) & 0xf) as u64);
     values[5] = ((((bytes[32]) & 0xf) as u64) << 48)
-        | (((bytes[33]) as u64) << 40)
-        | (((bytes[34]) as u64) << 32)
-        | (((bytes[35]) as u64) << 24)
-        | (((bytes[36]) as u64) << 16)
-        | (((bytes[37]) as u64) << 8)
-        | ((bytes[38]) as u64);
-    values[6] = (((bytes[39]) as u64) << 44)
-        | (((bytes[40]) as u64) << 36)
-        | (((bytes[41]) as u64) << 28)
-        | (((bytes[42]) as u64) << 20)
-        | (((bytes[43]) as u64) << 12)
-        | (((bytes[44]) as u64) << 4)
+        | ((bytes[33] as u64) << 40)
+        | ((bytes[34] as u64) << 32)
+        | ((bytes[35] as u64) << 24)
+        | ((bytes[36] as u64) << 16)
+        | ((bytes[37] as u64) << 8)
+        | (bytes[38] as u64);
+    values[6] = ((bytes[39] as u64) << 44)
+        | ((bytes[40] as u64) << 36)
+        | ((bytes[41] as u64) << 28)
+        | ((bytes[42] as u64) << 20)
+        | ((bytes[43] as u64) << 12)
+        | ((bytes[44] as u64) << 4)
         | (((bytes[45] >> 4) & 0xf) as u64);
     values[7] = ((((bytes[45]) & 0xf) as u64) << 48)
-        | (((bytes[46]) as u64) << 40)
-        | (((bytes[47]) as u64) << 32)
-        | (((bytes[48]) as u64) << 24)
-        | (((bytes[49]) as u64) << 16)
-        | (((bytes[50]) as u64) << 8)
-        | ((bytes[51]) as u64);
+        | ((bytes[46] as u64) << 40)
+        | ((bytes[47] as u64) << 32)
+        | ((bytes[48] as u64) << 24)
+        | ((bytes[49] as u64) << 16)
+        | ((bytes[50] as u64) << 8)
+        | (bytes[51] as u64);
 }
 
 #[inline]
 fn unpack_bits_53(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 45)
-        | (((bytes[1]) as u64) << 37)
-        | (((bytes[2]) as u64) << 29)
-        | (((bytes[3]) as u64) << 21)
-        | (((bytes[4]) as u64) << 13)
-        | (((bytes[5]) as u64) << 5)
+    values[0] = ((bytes[0] as u64) << 45)
+        | ((bytes[1] as u64) << 37)
+        | ((bytes[2] as u64) << 29)
+        | ((bytes[3] as u64) << 21)
+        | ((bytes[4] as u64) << 13)
+        | ((bytes[5] as u64) << 5)
         | (((bytes[6] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[6]) & 0x7) as u64) << 50)
-        | (((bytes[7]) as u64) << 42)
-        | (((bytes[8]) as u64) << 34)
-        | (((bytes[9]) as u64) << 26)
-        | (((bytes[10]) as u64) << 18)
-        | (((bytes[11]) as u64) << 10)
-        | (((bytes[12]) as u64) << 2)
+        | ((bytes[7] as u64) << 42)
+        | ((bytes[8] as u64) << 34)
+        | ((bytes[9] as u64) << 26)
+        | ((bytes[10] as u64) << 18)
+        | ((bytes[11] as u64) << 10)
+        | ((bytes[12] as u64) << 2)
         | (((bytes[13] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[13]) & 0x3f) as u64) << 47)
-        | (((bytes[14]) as u64) << 39)
-        | (((bytes[15]) as u64) << 31)
-        | (((bytes[16]) as u64) << 23)
-        | (((bytes[17]) as u64) << 15)
-        | (((bytes[18]) as u64) << 7)
+        | ((bytes[14] as u64) << 39)
+        | ((bytes[15] as u64) << 31)
+        | ((bytes[16] as u64) << 23)
+        | ((bytes[17] as u64) << 15)
+        | ((bytes[18] as u64) << 7)
         | (((bytes[19] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[19]) & 0x1) as u64) << 52)
-        | (((bytes[20]) as u64) << 44)
-        | (((bytes[21]) as u64) << 36)
-        | (((bytes[22]) as u64) << 28)
-        | (((bytes[23]) as u64) << 20)
-        | (((bytes[24]) as u64) << 12)
-        | (((bytes[25]) as u64) << 4)
+        | ((bytes[20] as u64) << 44)
+        | ((bytes[21] as u64) << 36)
+        | ((bytes[22] as u64) << 28)
+        | ((bytes[23] as u64) << 20)
+        | ((bytes[24] as u64) << 12)
+        | ((bytes[25] as u64) << 4)
         | (((bytes[26] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[26]) & 0xf) as u64) << 49)
-        | (((bytes[27]) as u64) << 41)
-        | (((bytes[28]) as u64) << 33)
-        | (((bytes[29]) as u64) << 25)
-        | (((bytes[30]) as u64) << 17)
-        | (((bytes[31]) as u64) << 9)
-        | (((bytes[32]) as u64) << 1)
+        | ((bytes[27] as u64) << 41)
+        | ((bytes[28] as u64) << 33)
+        | ((bytes[29] as u64) << 25)
+        | ((bytes[30] as u64) << 17)
+        | ((bytes[31] as u64) << 9)
+        | ((bytes[32] as u64) << 1)
         | (((bytes[33] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[33]) & 0x7f) as u64) << 46)
-        | (((bytes[34]) as u64) << 38)
-        | (((bytes[35]) as u64) << 30)
-        | (((bytes[36]) as u64) << 22)
-        | (((bytes[37]) as u64) << 14)
-        | (((bytes[38]) as u64) << 6)
+        | ((bytes[34] as u64) << 38)
+        | ((bytes[35] as u64) << 30)
+        | ((bytes[36] as u64) << 22)
+        | ((bytes[37] as u64) << 14)
+        | ((bytes[38] as u64) << 6)
         | (((bytes[39] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[39]) & 0x3) as u64) << 51)
-        | (((bytes[40]) as u64) << 43)
-        | (((bytes[41]) as u64) << 35)
-        | (((bytes[42]) as u64) << 27)
-        | (((bytes[43]) as u64) << 19)
-        | (((bytes[44]) as u64) << 11)
-        | (((bytes[45]) as u64) << 3)
+        | ((bytes[40] as u64) << 43)
+        | ((bytes[41] as u64) << 35)
+        | ((bytes[42] as u64) << 27)
+        | ((bytes[43] as u64) << 19)
+        | ((bytes[44] as u64) << 11)
+        | ((bytes[45] as u64) << 3)
         | (((bytes[46] >> 5) & 0x7) as u64);
     values[7] = ((((bytes[46]) & 0x1f) as u64) << 48)
-        | (((bytes[47]) as u64) << 40)
-        | (((bytes[48]) as u64) << 32)
-        | (((bytes[49]) as u64) << 24)
-        | (((bytes[50]) as u64) << 16)
-        | (((bytes[51]) as u64) << 8)
-        | ((bytes[52]) as u64);
+        | ((bytes[47] as u64) << 40)
+        | ((bytes[48] as u64) << 32)
+        | ((bytes[49] as u64) << 24)
+        | ((bytes[50] as u64) << 16)
+        | ((bytes[51] as u64) << 8)
+        | (bytes[52] as u64);
 }
 
 #[inline]
 fn unpack_bits_54(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 46)
-        | (((bytes[1]) as u64) << 38)
-        | (((bytes[2]) as u64) << 30)
-        | (((bytes[3]) as u64) << 22)
-        | (((bytes[4]) as u64) << 14)
-        | (((bytes[5]) as u64) << 6)
+    values[0] = ((bytes[0] as u64) << 46)
+        | ((bytes[1] as u64) << 38)
+        | ((bytes[2] as u64) << 30)
+        | ((bytes[3] as u64) << 22)
+        | ((bytes[4] as u64) << 14)
+        | ((bytes[5] as u64) << 6)
         | (((bytes[6] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[6]) & 0x3) as u64) << 52)
-        | (((bytes[7]) as u64) << 44)
-        | (((bytes[8]) as u64) << 36)
-        | (((bytes[9]) as u64) << 28)
-        | (((bytes[10]) as u64) << 20)
-        | (((bytes[11]) as u64) << 12)
-        | (((bytes[12]) as u64) << 4)
+        | ((bytes[7] as u64) << 44)
+        | ((bytes[8] as u64) << 36)
+        | ((bytes[9] as u64) << 28)
+        | ((bytes[10] as u64) << 20)
+        | ((bytes[11] as u64) << 12)
+        | ((bytes[12] as u64) << 4)
         | (((bytes[13] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[13]) & 0xf) as u64) << 50)
-        | (((bytes[14]) as u64) << 42)
-        | (((bytes[15]) as u64) << 34)
-        | (((bytes[16]) as u64) << 26)
-        | (((bytes[17]) as u64) << 18)
-        | (((bytes[18]) as u64) << 10)
-        | (((bytes[19]) as u64) << 2)
+        | ((bytes[14] as u64) << 42)
+        | ((bytes[15] as u64) << 34)
+        | ((bytes[16] as u64) << 26)
+        | ((bytes[17] as u64) << 18)
+        | ((bytes[18] as u64) << 10)
+        | ((bytes[19] as u64) << 2)
         | (((bytes[20] >> 6) & 0x3) as u64);
     values[3] = ((((bytes[20]) & 0x3f) as u64) << 48)
-        | (((bytes[21]) as u64) << 40)
-        | (((bytes[22]) as u64) << 32)
-        | (((bytes[23]) as u64) << 24)
-        | (((bytes[24]) as u64) << 16)
-        | (((bytes[25]) as u64) << 8)
-        | ((bytes[26]) as u64);
-    values[4] = (((bytes[27]) as u64) << 46)
-        | (((bytes[28]) as u64) << 38)
-        | (((bytes[29]) as u64) << 30)
-        | (((bytes[30]) as u64) << 22)
-        | (((bytes[31]) as u64) << 14)
-        | (((bytes[32]) as u64) << 6)
+        | ((bytes[21] as u64) << 40)
+        | ((bytes[22] as u64) << 32)
+        | ((bytes[23] as u64) << 24)
+        | ((bytes[24] as u64) << 16)
+        | ((bytes[25] as u64) << 8)
+        | (bytes[26] as u64);
+    values[4] = ((bytes[27] as u64) << 46)
+        | ((bytes[28] as u64) << 38)
+        | ((bytes[29] as u64) << 30)
+        | ((bytes[30] as u64) << 22)
+        | ((bytes[31] as u64) << 14)
+        | ((bytes[32] as u64) << 6)
         | (((bytes[33] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[33]) & 0x3) as u64) << 52)
-        | (((bytes[34]) as u64) << 44)
-        | (((bytes[35]) as u64) << 36)
-        | (((bytes[36]) as u64) << 28)
-        | (((bytes[37]) as u64) << 20)
-        | (((bytes[38]) as u64) << 12)
-        | (((bytes[39]) as u64) << 4)
+        | ((bytes[34] as u64) << 44)
+        | ((bytes[35] as u64) << 36)
+        | ((bytes[36] as u64) << 28)
+        | ((bytes[37] as u64) << 20)
+        | ((bytes[38] as u64) << 12)
+        | ((bytes[39] as u64) << 4)
         | (((bytes[40] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[40]) & 0xf) as u64) << 50)
-        | (((bytes[41]) as u64) << 42)
-        | (((bytes[42]) as u64) << 34)
-        | (((bytes[43]) as u64) << 26)
-        | (((bytes[44]) as u64) << 18)
-        | (((bytes[45]) as u64) << 10)
-        | (((bytes[46]) as u64) << 2)
+        | ((bytes[41] as u64) << 42)
+        | ((bytes[42] as u64) << 34)
+        | ((bytes[43] as u64) << 26)
+        | ((bytes[44] as u64) << 18)
+        | ((bytes[45] as u64) << 10)
+        | ((bytes[46] as u64) << 2)
         | (((bytes[47] >> 6) & 0x3) as u64);
     values[7] = ((((bytes[47]) & 0x3f) as u64) << 48)
-        | (((bytes[48]) as u64) << 40)
-        | (((bytes[49]) as u64) << 32)
-        | (((bytes[50]) as u64) << 24)
-        | (((bytes[51]) as u64) << 16)
-        | (((bytes[52]) as u64) << 8)
-        | ((bytes[53]) as u64);
+        | ((bytes[48] as u64) << 40)
+        | ((bytes[49] as u64) << 32)
+        | ((bytes[50] as u64) << 24)
+        | ((bytes[51] as u64) << 16)
+        | ((bytes[52] as u64) << 8)
+        | (bytes[53] as u64);
 }
 
 #[inline]
 fn unpack_bits_55(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 47)
-        | (((bytes[1]) as u64) << 39)
-        | (((bytes[2]) as u64) << 31)
-        | (((bytes[3]) as u64) << 23)
-        | (((bytes[4]) as u64) << 15)
-        | (((bytes[5]) as u64) << 7)
+    values[0] = ((bytes[0] as u64) << 47)
+        | ((bytes[1] as u64) << 39)
+        | ((bytes[2] as u64) << 31)
+        | ((bytes[3] as u64) << 23)
+        | ((bytes[4] as u64) << 15)
+        | ((bytes[5] as u64) << 7)
         | (((bytes[6] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[6]) & 0x1) as u64) << 54)
-        | (((bytes[7]) as u64) << 46)
-        | (((bytes[8]) as u64) << 38)
-        | (((bytes[9]) as u64) << 30)
-        | (((bytes[10]) as u64) << 22)
-        | (((bytes[11]) as u64) << 14)
-        | (((bytes[12]) as u64) << 6)
+        | ((bytes[7] as u64) << 46)
+        | ((bytes[8] as u64) << 38)
+        | ((bytes[9] as u64) << 30)
+        | ((bytes[10] as u64) << 22)
+        | ((bytes[11] as u64) << 14)
+        | ((bytes[12] as u64) << 6)
         | (((bytes[13] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[13]) & 0x3) as u64) << 53)
-        | (((bytes[14]) as u64) << 45)
-        | (((bytes[15]) as u64) << 37)
-        | (((bytes[16]) as u64) << 29)
-        | (((bytes[17]) as u64) << 21)
-        | (((bytes[18]) as u64) << 13)
-        | (((bytes[19]) as u64) << 5)
+        | ((bytes[14] as u64) << 45)
+        | ((bytes[15] as u64) << 37)
+        | ((bytes[16] as u64) << 29)
+        | ((bytes[17] as u64) << 21)
+        | ((bytes[18] as u64) << 13)
+        | ((bytes[19] as u64) << 5)
         | (((bytes[20] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[20]) & 0x7) as u64) << 52)
-        | (((bytes[21]) as u64) << 44)
-        | (((bytes[22]) as u64) << 36)
-        | (((bytes[23]) as u64) << 28)
-        | (((bytes[24]) as u64) << 20)
-        | (((bytes[25]) as u64) << 12)
-        | (((bytes[26]) as u64) << 4)
+        | ((bytes[21] as u64) << 44)
+        | ((bytes[22] as u64) << 36)
+        | ((bytes[23] as u64) << 28)
+        | ((bytes[24] as u64) << 20)
+        | ((bytes[25] as u64) << 12)
+        | ((bytes[26] as u64) << 4)
         | (((bytes[27] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[27]) & 0xf) as u64) << 51)
-        | (((bytes[28]) as u64) << 43)
-        | (((bytes[29]) as u64) << 35)
-        | (((bytes[30]) as u64) << 27)
-        | (((bytes[31]) as u64) << 19)
-        | (((bytes[32]) as u64) << 11)
-        | (((bytes[33]) as u64) << 3)
+        | ((bytes[28] as u64) << 43)
+        | ((bytes[29] as u64) << 35)
+        | ((bytes[30] as u64) << 27)
+        | ((bytes[31] as u64) << 19)
+        | ((bytes[32] as u64) << 11)
+        | ((bytes[33] as u64) << 3)
         | (((bytes[34] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[34]) & 0x1f) as u64) << 50)
-        | (((bytes[35]) as u64) << 42)
-        | (((bytes[36]) as u64) << 34)
-        | (((bytes[37]) as u64) << 26)
-        | (((bytes[38]) as u64) << 18)
-        | (((bytes[39]) as u64) << 10)
-        | (((bytes[40]) as u64) << 2)
+        | ((bytes[35] as u64) << 42)
+        | ((bytes[36] as u64) << 34)
+        | ((bytes[37] as u64) << 26)
+        | ((bytes[38] as u64) << 18)
+        | ((bytes[39] as u64) << 10)
+        | ((bytes[40] as u64) << 2)
         | (((bytes[41] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[41]) & 0x3f) as u64) << 49)
-        | (((bytes[42]) as u64) << 41)
-        | (((bytes[43]) as u64) << 33)
-        | (((bytes[44]) as u64) << 25)
-        | (((bytes[45]) as u64) << 17)
-        | (((bytes[46]) as u64) << 9)
-        | (((bytes[47]) as u64) << 1)
+        | ((bytes[42] as u64) << 41)
+        | ((bytes[43] as u64) << 33)
+        | ((bytes[44] as u64) << 25)
+        | ((bytes[45] as u64) << 17)
+        | ((bytes[46] as u64) << 9)
+        | ((bytes[47] as u64) << 1)
         | (((bytes[48] >> 7) & 0x1) as u64);
     values[7] = ((((bytes[48]) & 0x7f) as u64) << 48)
-        | (((bytes[49]) as u64) << 40)
-        | (((bytes[50]) as u64) << 32)
-        | (((bytes[51]) as u64) << 24)
-        | (((bytes[52]) as u64) << 16)
-        | (((bytes[53]) as u64) << 8)
-        | ((bytes[54]) as u64);
+        | ((bytes[49] as u64) << 40)
+        | ((bytes[50] as u64) << 32)
+        | ((bytes[51] as u64) << 24)
+        | ((bytes[52] as u64) << 16)
+        | ((bytes[53] as u64) << 8)
+        | (bytes[54] as u64);
 }
 
 #[inline]
 fn unpack_bits_56(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 48)
-        | (((bytes[1]) as u64) << 40)
-        | (((bytes[2]) as u64) << 32)
-        | (((bytes[3]) as u64) << 24)
-        | (((bytes[4]) as u64) << 16)
-        | (((bytes[5]) as u64) << 8)
-        | ((bytes[6]) as u64);
-    values[1] = (((bytes[7]) as u64) << 48)
-        | (((bytes[8]) as u64) << 40)
-        | (((bytes[9]) as u64) << 32)
-        | (((bytes[10]) as u64) << 24)
-        | (((bytes[11]) as u64) << 16)
-        | (((bytes[12]) as u64) << 8)
-        | ((bytes[13]) as u64);
-    values[2] = (((bytes[14]) as u64) << 48)
-        | (((bytes[15]) as u64) << 40)
-        | (((bytes[16]) as u64) << 32)
-        | (((bytes[17]) as u64) << 24)
-        | (((bytes[18]) as u64) << 16)
-        | (((bytes[19]) as u64) << 8)
-        | ((bytes[20]) as u64);
-    values[3] = (((bytes[21]) as u64) << 48)
-        | (((bytes[22]) as u64) << 40)
-        | (((bytes[23]) as u64) << 32)
-        | (((bytes[24]) as u64) << 24)
-        | (((bytes[25]) as u64) << 16)
-        | (((bytes[26]) as u64) << 8)
-        | ((bytes[27]) as u64);
-    values[4] = (((bytes[28]) as u64) << 48)
-        | (((bytes[29]) as u64) << 40)
-        | (((bytes[30]) as u64) << 32)
-        | (((bytes[31]) as u64) << 24)
-        | (((bytes[32]) as u64) << 16)
-        | (((bytes[33]) as u64) << 8)
-        | ((bytes[34]) as u64);
-    values[5] = (((bytes[35]) as u64) << 48)
-        | (((bytes[36]) as u64) << 40)
-        | (((bytes[37]) as u64) << 32)
-        | (((bytes[38]) as u64) << 24)
-        | (((bytes[39]) as u64) << 16)
-        | (((bytes[40]) as u64) << 8)
-        | ((bytes[41]) as u64);
-    values[6] = (((bytes[42]) as u64) << 48)
-        | (((bytes[43]) as u64) << 40)
-        | (((bytes[44]) as u64) << 32)
-        | (((bytes[45]) as u64) << 24)
-        | (((bytes[46]) as u64) << 16)
-        | (((bytes[47]) as u64) << 8)
-        | ((bytes[48]) as u64);
-    values[7] = (((bytes[49]) as u64) << 48)
-        | (((bytes[50]) as u64) << 40)
-        | (((bytes[51]) as u64) << 32)
-        | (((bytes[52]) as u64) << 24)
-        | (((bytes[53]) as u64) << 16)
-        | (((bytes[54]) as u64) << 8)
-        | ((bytes[55]) as u64);
+    values[0] = ((bytes[0] as u64) << 48)
+        | ((bytes[1] as u64) << 40)
+        | ((bytes[2] as u64) << 32)
+        | ((bytes[3] as u64) << 24)
+        | ((bytes[4] as u64) << 16)
+        | ((bytes[5] as u64) << 8)
+        | (bytes[6] as u64);
+    values[1] = ((bytes[7] as u64) << 48)
+        | ((bytes[8] as u64) << 40)
+        | ((bytes[9] as u64) << 32)
+        | ((bytes[10] as u64) << 24)
+        | ((bytes[11] as u64) << 16)
+        | ((bytes[12] as u64) << 8)
+        | (bytes[13] as u64);
+    values[2] = ((bytes[14] as u64) << 48)
+        | ((bytes[15] as u64) << 40)
+        | ((bytes[16] as u64) << 32)
+        | ((bytes[17] as u64) << 24)
+        | ((bytes[18] as u64) << 16)
+        | ((bytes[19] as u64) << 8)
+        | (bytes[20] as u64);
+    values[3] = ((bytes[21] as u64) << 48)
+        | ((bytes[22] as u64) << 40)
+        | ((bytes[23] as u64) << 32)
+        | ((bytes[24] as u64) << 24)
+        | ((bytes[25] as u64) << 16)
+        | ((bytes[26] as u64) << 8)
+        | (bytes[27] as u64);
+    values[4] = ((bytes[28] as u64) << 48)
+        | ((bytes[29] as u64) << 40)
+        | ((bytes[30] as u64) << 32)
+        | ((bytes[31] as u64) << 24)
+        | ((bytes[32] as u64) << 16)
+        | ((bytes[33] as u64) << 8)
+        | (bytes[34] as u64);
+    values[5] = ((bytes[35] as u64) << 48)
+        | ((bytes[36] as u64) << 40)
+        | ((bytes[37] as u64) << 32)
+        | ((bytes[38] as u64) << 24)
+        | ((bytes[39] as u64) << 16)
+        | ((bytes[40] as u64) << 8)
+        | (bytes[41] as u64);
+    values[6] = ((bytes[42] as u64) << 48)
+        | ((bytes[43] as u64) << 40)
+        | ((bytes[44] as u64) << 32)
+        | ((bytes[45] as u64) << 24)
+        | ((bytes[46] as u64) << 16)
+        | ((bytes[47] as u64) << 8)
+        | (bytes[48] as u64);
+    values[7] = ((bytes[49] as u64) << 48)
+        | ((bytes[50] as u64) << 40)
+        | ((bytes[51] as u64) << 32)
+        | ((bytes[52] as u64) << 24)
+        | ((bytes[53] as u64) << 16)
+        | ((bytes[54] as u64) << 8)
+        | (bytes[55] as u64);
 }
 
 #[inline]
 fn unpack_bits_57(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 49)
-        | (((bytes[1]) as u64) << 41)
-        | (((bytes[2]) as u64) << 33)
-        | (((bytes[3]) as u64) << 25)
-        | (((bytes[4]) as u64) << 17)
-        | (((bytes[5]) as u64) << 9)
-        | (((bytes[6]) as u64) << 1)
+    values[0] = ((bytes[0] as u64) << 49)
+        | ((bytes[1] as u64) << 41)
+        | ((bytes[2] as u64) << 33)
+        | ((bytes[3] as u64) << 25)
+        | ((bytes[4] as u64) << 17)
+        | ((bytes[5] as u64) << 9)
+        | ((bytes[6] as u64) << 1)
         | (((bytes[7] >> 7) & 0x1) as u64);
     values[1] = ((((bytes[7]) & 0x7f) as u64) << 50)
-        | (((bytes[8]) as u64) << 42)
-        | (((bytes[9]) as u64) << 34)
-        | (((bytes[10]) as u64) << 26)
-        | (((bytes[11]) as u64) << 18)
-        | (((bytes[12]) as u64) << 10)
-        | (((bytes[13]) as u64) << 2)
+        | ((bytes[8] as u64) << 42)
+        | ((bytes[9] as u64) << 34)
+        | ((bytes[10] as u64) << 26)
+        | ((bytes[11] as u64) << 18)
+        | ((bytes[12] as u64) << 10)
+        | ((bytes[13] as u64) << 2)
         | (((bytes[14] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[14]) & 0x3f) as u64) << 51)
-        | (((bytes[15]) as u64) << 43)
-        | (((bytes[16]) as u64) << 35)
-        | (((bytes[17]) as u64) << 27)
-        | (((bytes[18]) as u64) << 19)
-        | (((bytes[19]) as u64) << 11)
-        | (((bytes[20]) as u64) << 3)
+        | ((bytes[15] as u64) << 43)
+        | ((bytes[16] as u64) << 35)
+        | ((bytes[17] as u64) << 27)
+        | ((bytes[18] as u64) << 19)
+        | ((bytes[19] as u64) << 11)
+        | ((bytes[20] as u64) << 3)
         | (((bytes[21] >> 5) & 0x7) as u64);
     values[3] = ((((bytes[21]) & 0x1f) as u64) << 52)
-        | (((bytes[22]) as u64) << 44)
-        | (((bytes[23]) as u64) << 36)
-        | (((bytes[24]) as u64) << 28)
-        | (((bytes[25]) as u64) << 20)
-        | (((bytes[26]) as u64) << 12)
-        | (((bytes[27]) as u64) << 4)
+        | ((bytes[22] as u64) << 44)
+        | ((bytes[23] as u64) << 36)
+        | ((bytes[24] as u64) << 28)
+        | ((bytes[25] as u64) << 20)
+        | ((bytes[26] as u64) << 12)
+        | ((bytes[27] as u64) << 4)
         | (((bytes[28] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[28]) & 0xf) as u64) << 53)
-        | (((bytes[29]) as u64) << 45)
-        | (((bytes[30]) as u64) << 37)
-        | (((bytes[31]) as u64) << 29)
-        | (((bytes[32]) as u64) << 21)
-        | (((bytes[33]) as u64) << 13)
-        | (((bytes[34]) as u64) << 5)
+        | ((bytes[29] as u64) << 45)
+        | ((bytes[30] as u64) << 37)
+        | ((bytes[31] as u64) << 29)
+        | ((bytes[32] as u64) << 21)
+        | ((bytes[33] as u64) << 13)
+        | ((bytes[34] as u64) << 5)
         | (((bytes[35] >> 3) & 0x1f) as u64);
     values[5] = ((((bytes[35]) & 0x7) as u64) << 54)
-        | (((bytes[36]) as u64) << 46)
-        | (((bytes[37]) as u64) << 38)
-        | (((bytes[38]) as u64) << 30)
-        | (((bytes[39]) as u64) << 22)
-        | (((bytes[40]) as u64) << 14)
-        | (((bytes[41]) as u64) << 6)
+        | ((bytes[36] as u64) << 46)
+        | ((bytes[37] as u64) << 38)
+        | ((bytes[38] as u64) << 30)
+        | ((bytes[39] as u64) << 22)
+        | ((bytes[40] as u64) << 14)
+        | ((bytes[41] as u64) << 6)
         | (((bytes[42] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[42]) & 0x3) as u64) << 55)
-        | (((bytes[43]) as u64) << 47)
-        | (((bytes[44]) as u64) << 39)
-        | (((bytes[45]) as u64) << 31)
-        | (((bytes[46]) as u64) << 23)
-        | (((bytes[47]) as u64) << 15)
-        | (((bytes[48]) as u64) << 7)
+        | ((bytes[43] as u64) << 47)
+        | ((bytes[44] as u64) << 39)
+        | ((bytes[45] as u64) << 31)
+        | ((bytes[46] as u64) << 23)
+        | ((bytes[47] as u64) << 15)
+        | ((bytes[48] as u64) << 7)
         | (((bytes[49] >> 1) & 0x7f) as u64);
     values[7] = ((((bytes[49]) & 0x1) as u64) << 56)
-        | (((bytes[50]) as u64) << 48)
-        | (((bytes[51]) as u64) << 40)
-        | (((bytes[52]) as u64) << 32)
-        | (((bytes[53]) as u64) << 24)
-        | (((bytes[54]) as u64) << 16)
-        | (((bytes[55]) as u64) << 8)
-        | ((bytes[56]) as u64);
+        | ((bytes[50] as u64) << 48)
+        | ((bytes[51] as u64) << 40)
+        | ((bytes[52] as u64) << 32)
+        | ((bytes[53] as u64) << 24)
+        | ((bytes[54] as u64) << 16)
+        | ((bytes[55] as u64) << 8)
+        | (bytes[56] as u64);
 }
 
 #[inline]
 fn unpack_bits_58(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 50)
-        | (((bytes[1]) as u64) << 42)
-        | (((bytes[2]) as u64) << 34)
-        | (((bytes[3]) as u64) << 26)
-        | (((bytes[4]) as u64) << 18)
-        | (((bytes[5]) as u64) << 10)
-        | (((bytes[6]) as u64) << 2)
+    values[0] = ((bytes[0] as u64) << 50)
+        | ((bytes[1] as u64) << 42)
+        | ((bytes[2] as u64) << 34)
+        | ((bytes[3] as u64) << 26)
+        | ((bytes[4] as u64) << 18)
+        | ((bytes[5] as u64) << 10)
+        | ((bytes[6] as u64) << 2)
         | (((bytes[7] >> 6) & 0x3) as u64);
     values[1] = ((((bytes[7]) & 0x3f) as u64) << 52)
-        | (((bytes[8]) as u64) << 44)
-        | (((bytes[9]) as u64) << 36)
-        | (((bytes[10]) as u64) << 28)
-        | (((bytes[11]) as u64) << 20)
-        | (((bytes[12]) as u64) << 12)
-        | (((bytes[13]) as u64) << 4)
+        | ((bytes[8] as u64) << 44)
+        | ((bytes[9] as u64) << 36)
+        | ((bytes[10] as u64) << 28)
+        | ((bytes[11] as u64) << 20)
+        | ((bytes[12] as u64) << 12)
+        | ((bytes[13] as u64) << 4)
         | (((bytes[14] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[14]) & 0xf) as u64) << 54)
-        | (((bytes[15]) as u64) << 46)
-        | (((bytes[16]) as u64) << 38)
-        | (((bytes[17]) as u64) << 30)
-        | (((bytes[18]) as u64) << 22)
-        | (((bytes[19]) as u64) << 14)
-        | (((bytes[20]) as u64) << 6)
+        | ((bytes[15] as u64) << 46)
+        | ((bytes[16] as u64) << 38)
+        | ((bytes[17] as u64) << 30)
+        | ((bytes[18] as u64) << 22)
+        | ((bytes[19] as u64) << 14)
+        | ((bytes[20] as u64) << 6)
         | (((bytes[21] >> 2) & 0x3f) as u64);
     values[3] = ((((bytes[21]) & 0x3) as u64) << 56)
-        | (((bytes[22]) as u64) << 48)
-        | (((bytes[23]) as u64) << 40)
-        | (((bytes[24]) as u64) << 32)
-        | (((bytes[25]) as u64) << 24)
-        | (((bytes[26]) as u64) << 16)
-        | (((bytes[27]) as u64) << 8)
-        | ((bytes[28]) as u64);
-    values[4] = (((bytes[29]) as u64) << 50)
-        | (((bytes[30]) as u64) << 42)
-        | (((bytes[31]) as u64) << 34)
-        | (((bytes[32]) as u64) << 26)
-        | (((bytes[33]) as u64) << 18)
-        | (((bytes[34]) as u64) << 10)
-        | (((bytes[35]) as u64) << 2)
+        | ((bytes[22] as u64) << 48)
+        | ((bytes[23] as u64) << 40)
+        | ((bytes[24] as u64) << 32)
+        | ((bytes[25] as u64) << 24)
+        | ((bytes[26] as u64) << 16)
+        | ((bytes[27] as u64) << 8)
+        | (bytes[28] as u64);
+    values[4] = ((bytes[29] as u64) << 50)
+        | ((bytes[30] as u64) << 42)
+        | ((bytes[31] as u64) << 34)
+        | ((bytes[32] as u64) << 26)
+        | ((bytes[33] as u64) << 18)
+        | ((bytes[34] as u64) << 10)
+        | ((bytes[35] as u64) << 2)
         | (((bytes[36] >> 6) & 0x3) as u64);
     values[5] = ((((bytes[36]) & 0x3f) as u64) << 52)
-        | (((bytes[37]) as u64) << 44)
-        | (((bytes[38]) as u64) << 36)
-        | (((bytes[39]) as u64) << 28)
-        | (((bytes[40]) as u64) << 20)
-        | (((bytes[41]) as u64) << 12)
-        | (((bytes[42]) as u64) << 4)
+        | ((bytes[37] as u64) << 44)
+        | ((bytes[38] as u64) << 36)
+        | ((bytes[39] as u64) << 28)
+        | ((bytes[40] as u64) << 20)
+        | ((bytes[41] as u64) << 12)
+        | ((bytes[42] as u64) << 4)
         | (((bytes[43] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[43]) & 0xf) as u64) << 54)
-        | (((bytes[44]) as u64) << 46)
-        | (((bytes[45]) as u64) << 38)
-        | (((bytes[46]) as u64) << 30)
-        | (((bytes[47]) as u64) << 22)
-        | (((bytes[48]) as u64) << 14)
-        | (((bytes[49]) as u64) << 6)
+        | ((bytes[44] as u64) << 46)
+        | ((bytes[45] as u64) << 38)
+        | ((bytes[46] as u64) << 30)
+        | ((bytes[47] as u64) << 22)
+        | ((bytes[48] as u64) << 14)
+        | ((bytes[49] as u64) << 6)
         | (((bytes[50] >> 2) & 0x3f) as u64);
     values[7] = ((((bytes[50]) & 0x3) as u64) << 56)
-        | (((bytes[51]) as u64) << 48)
-        | (((bytes[52]) as u64) << 40)
-        | (((bytes[53]) as u64) << 32)
-        | (((bytes[54]) as u64) << 24)
-        | (((bytes[55]) as u64) << 16)
-        | (((bytes[56]) as u64) << 8)
-        | ((bytes[57]) as u64);
+        | ((bytes[51] as u64) << 48)
+        | ((bytes[52] as u64) << 40)
+        | ((bytes[53] as u64) << 32)
+        | ((bytes[54] as u64) << 24)
+        | ((bytes[55] as u64) << 16)
+        | ((bytes[56] as u64) << 8)
+        | (bytes[57] as u64);
 }
 
 #[inline]
 fn unpack_bits_59(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 51)
-        | (((bytes[1]) as u64) << 43)
-        | (((bytes[2]) as u64) << 35)
-        | (((bytes[3]) as u64) << 27)
-        | (((bytes[4]) as u64) << 19)
-        | (((bytes[5]) as u64) << 11)
-        | (((bytes[6]) as u64) << 3)
+    values[0] = ((bytes[0] as u64) << 51)
+        | ((bytes[1] as u64) << 43)
+        | ((bytes[2] as u64) << 35)
+        | ((bytes[3] as u64) << 27)
+        | ((bytes[4] as u64) << 19)
+        | ((bytes[5] as u64) << 11)
+        | ((bytes[6] as u64) << 3)
         | (((bytes[7] >> 5) & 0x7) as u64);
     values[1] = ((((bytes[7]) & 0x1f) as u64) << 54)
-        | (((bytes[8]) as u64) << 46)
-        | (((bytes[9]) as u64) << 38)
-        | (((bytes[10]) as u64) << 30)
-        | (((bytes[11]) as u64) << 22)
-        | (((bytes[12]) as u64) << 14)
-        | (((bytes[13]) as u64) << 6)
+        | ((bytes[8] as u64) << 46)
+        | ((bytes[9] as u64) << 38)
+        | ((bytes[10] as u64) << 30)
+        | ((bytes[11] as u64) << 22)
+        | ((bytes[12] as u64) << 14)
+        | ((bytes[13] as u64) << 6)
         | (((bytes[14] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[14]) & 0x3) as u64) << 57)
-        | (((bytes[15]) as u64) << 49)
-        | (((bytes[16]) as u64) << 41)
-        | (((bytes[17]) as u64) << 33)
-        | (((bytes[18]) as u64) << 25)
-        | (((bytes[19]) as u64) << 17)
-        | (((bytes[20]) as u64) << 9)
-        | (((bytes[21]) as u64) << 1)
+        | ((bytes[15] as u64) << 49)
+        | ((bytes[16] as u64) << 41)
+        | ((bytes[17] as u64) << 33)
+        | ((bytes[18] as u64) << 25)
+        | ((bytes[19] as u64) << 17)
+        | ((bytes[20] as u64) << 9)
+        | ((bytes[21] as u64) << 1)
         | (((bytes[22] >> 7) & 0x1) as u64);
     values[3] = ((((bytes[22]) & 0x7f) as u64) << 52)
-        | (((bytes[23]) as u64) << 44)
-        | (((bytes[24]) as u64) << 36)
-        | (((bytes[25]) as u64) << 28)
-        | (((bytes[26]) as u64) << 20)
-        | (((bytes[27]) as u64) << 12)
-        | (((bytes[28]) as u64) << 4)
+        | ((bytes[23] as u64) << 44)
+        | ((bytes[24] as u64) << 36)
+        | ((bytes[25] as u64) << 28)
+        | ((bytes[26] as u64) << 20)
+        | ((bytes[27] as u64) << 12)
+        | ((bytes[28] as u64) << 4)
         | (((bytes[29] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[29]) & 0xf) as u64) << 55)
-        | (((bytes[30]) as u64) << 47)
-        | (((bytes[31]) as u64) << 39)
-        | (((bytes[32]) as u64) << 31)
-        | (((bytes[33]) as u64) << 23)
-        | (((bytes[34]) as u64) << 15)
-        | (((bytes[35]) as u64) << 7)
+        | ((bytes[30] as u64) << 47)
+        | ((bytes[31] as u64) << 39)
+        | ((bytes[32] as u64) << 31)
+        | ((bytes[33] as u64) << 23)
+        | ((bytes[34] as u64) << 15)
+        | ((bytes[35] as u64) << 7)
         | (((bytes[36] >> 1) & 0x7f) as u64);
     values[5] = ((((bytes[36]) & 0x1) as u64) << 58)
-        | (((bytes[37]) as u64) << 50)
-        | (((bytes[38]) as u64) << 42)
-        | (((bytes[39]) as u64) << 34)
-        | (((bytes[40]) as u64) << 26)
-        | (((bytes[41]) as u64) << 18)
-        | (((bytes[42]) as u64) << 10)
-        | (((bytes[43]) as u64) << 2)
+        | ((bytes[37] as u64) << 50)
+        | ((bytes[38] as u64) << 42)
+        | ((bytes[39] as u64) << 34)
+        | ((bytes[40] as u64) << 26)
+        | ((bytes[41] as u64) << 18)
+        | ((bytes[42] as u64) << 10)
+        | ((bytes[43] as u64) << 2)
         | (((bytes[44] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[44]) & 0x3f) as u64) << 53)
-        | (((bytes[45]) as u64) << 45)
-        | (((bytes[46]) as u64) << 37)
-        | (((bytes[47]) as u64) << 29)
-        | (((bytes[48]) as u64) << 21)
-        | (((bytes[49]) as u64) << 13)
-        | (((bytes[50]) as u64) << 5)
+        | ((bytes[45] as u64) << 45)
+        | ((bytes[46] as u64) << 37)
+        | ((bytes[47] as u64) << 29)
+        | ((bytes[48] as u64) << 21)
+        | ((bytes[49] as u64) << 13)
+        | ((bytes[50] as u64) << 5)
         | (((bytes[51] >> 3) & 0x1f) as u64);
     values[7] = ((((bytes[51]) & 0x7) as u64) << 56)
-        | (((bytes[52]) as u64) << 48)
-        | (((bytes[53]) as u64) << 40)
-        | (((bytes[54]) as u64) << 32)
-        | (((bytes[55]) as u64) << 24)
-        | (((bytes[56]) as u64) << 16)
-        | (((bytes[57]) as u64) << 8)
-        | ((bytes[58]) as u64);
+        | ((bytes[52] as u64) << 48)
+        | ((bytes[53] as u64) << 40)
+        | ((bytes[54] as u64) << 32)
+        | ((bytes[55] as u64) << 24)
+        | ((bytes[56] as u64) << 16)
+        | ((bytes[57] as u64) << 8)
+        | (bytes[58] as u64);
 }
 
 #[inline]
 fn unpack_bits_60(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 52)
-        | (((bytes[1]) as u64) << 44)
-        | (((bytes[2]) as u64) << 36)
-        | (((bytes[3]) as u64) << 28)
-        | (((bytes[4]) as u64) << 20)
-        | (((bytes[5]) as u64) << 12)
-        | (((bytes[6]) as u64) << 4)
+    values[0] = ((bytes[0] as u64) << 52)
+        | ((bytes[1] as u64) << 44)
+        | ((bytes[2] as u64) << 36)
+        | ((bytes[3] as u64) << 28)
+        | ((bytes[4] as u64) << 20)
+        | ((bytes[5] as u64) << 12)
+        | ((bytes[6] as u64) << 4)
         | (((bytes[7] >> 4) & 0xf) as u64);
     values[1] = ((((bytes[7]) & 0xf) as u64) << 56)
-        | (((bytes[8]) as u64) << 48)
-        | (((bytes[9]) as u64) << 40)
-        | (((bytes[10]) as u64) << 32)
-        | (((bytes[11]) as u64) << 24)
-        | (((bytes[12]) as u64) << 16)
-        | (((bytes[13]) as u64) << 8)
-        | ((bytes[14]) as u64);
-    values[2] = (((bytes[15]) as u64) << 52)
-        | (((bytes[16]) as u64) << 44)
-        | (((bytes[17]) as u64) << 36)
-        | (((bytes[18]) as u64) << 28)
-        | (((bytes[19]) as u64) << 20)
-        | (((bytes[20]) as u64) << 12)
-        | (((bytes[21]) as u64) << 4)
+        | ((bytes[8] as u64) << 48)
+        | ((bytes[9] as u64) << 40)
+        | ((bytes[10] as u64) << 32)
+        | ((bytes[11] as u64) << 24)
+        | ((bytes[12] as u64) << 16)
+        | ((bytes[13] as u64) << 8)
+        | (bytes[14] as u64);
+    values[2] = ((bytes[15] as u64) << 52)
+        | ((bytes[16] as u64) << 44)
+        | ((bytes[17] as u64) << 36)
+        | ((bytes[18] as u64) << 28)
+        | ((bytes[19] as u64) << 20)
+        | ((bytes[20] as u64) << 12)
+        | ((bytes[21] as u64) << 4)
         | (((bytes[22] >> 4) & 0xf) as u64);
     values[3] = ((((bytes[22]) & 0xf) as u64) << 56)
-        | (((bytes[23]) as u64) << 48)
-        | (((bytes[24]) as u64) << 40)
-        | (((bytes[25]) as u64) << 32)
-        | (((bytes[26]) as u64) << 24)
-        | (((bytes[27]) as u64) << 16)
-        | (((bytes[28]) as u64) << 8)
-        | ((bytes[29]) as u64);
-    values[4] = (((bytes[30]) as u64) << 52)
-        | (((bytes[31]) as u64) << 44)
-        | (((bytes[32]) as u64) << 36)
-        | (((bytes[33]) as u64) << 28)
-        | (((bytes[34]) as u64) << 20)
-        | (((bytes[35]) as u64) << 12)
-        | (((bytes[36]) as u64) << 4)
+        | ((bytes[23] as u64) << 48)
+        | ((bytes[24] as u64) << 40)
+        | ((bytes[25] as u64) << 32)
+        | ((bytes[26] as u64) << 24)
+        | ((bytes[27] as u64) << 16)
+        | ((bytes[28] as u64) << 8)
+        | (bytes[29] as u64);
+    values[4] = ((bytes[30] as u64) << 52)
+        | ((bytes[31] as u64) << 44)
+        | ((bytes[32] as u64) << 36)
+        | ((bytes[33] as u64) << 28)
+        | ((bytes[34] as u64) << 20)
+        | ((bytes[35] as u64) << 12)
+        | ((bytes[36] as u64) << 4)
         | (((bytes[37] >> 4) & 0xf) as u64);
     values[5] = ((((bytes[37]) & 0xf) as u64) << 56)
-        | (((bytes[38]) as u64) << 48)
-        | (((bytes[39]) as u64) << 40)
-        | (((bytes[40]) as u64) << 32)
-        | (((bytes[41]) as u64) << 24)
-        | (((bytes[42]) as u64) << 16)
-        | (((bytes[43]) as u64) << 8)
-        | ((bytes[44]) as u64);
-    values[6] = (((bytes[45]) as u64) << 52)
-        | (((bytes[46]) as u64) << 44)
-        | (((bytes[47]) as u64) << 36)
-        | (((bytes[48]) as u64) << 28)
-        | (((bytes[49]) as u64) << 20)
-        | (((bytes[50]) as u64) << 12)
-        | (((bytes[51]) as u64) << 4)
+        | ((bytes[38] as u64) << 48)
+        | ((bytes[39] as u64) << 40)
+        | ((bytes[40] as u64) << 32)
+        | ((bytes[41] as u64) << 24)
+        | ((bytes[42] as u64) << 16)
+        | ((bytes[43] as u64) << 8)
+        | (bytes[44] as u64);
+    values[6] = ((bytes[45] as u64) << 52)
+        | ((bytes[46] as u64) << 44)
+        | ((bytes[47] as u64) << 36)
+        | ((bytes[48] as u64) << 28)
+        | ((bytes[49] as u64) << 20)
+        | ((bytes[50] as u64) << 12)
+        | ((bytes[51] as u64) << 4)
         | (((bytes[52] >> 4) & 0xf) as u64);
     values[7] = ((((bytes[52]) & 0xf) as u64) << 56)
-        | (((bytes[53]) as u64) << 48)
-        | (((bytes[54]) as u64) << 40)
-        | (((bytes[55]) as u64) << 32)
-        | (((bytes[56]) as u64) << 24)
-        | (((bytes[57]) as u64) << 16)
-        | (((bytes[58]) as u64) << 8)
-        | ((bytes[59]) as u64);
+        | ((bytes[53] as u64) << 48)
+        | ((bytes[54] as u64) << 40)
+        | ((bytes[55] as u64) << 32)
+        | ((bytes[56] as u64) << 24)
+        | ((bytes[57] as u64) << 16)
+        | ((bytes[58] as u64) << 8)
+        | (bytes[59] as u64);
 }
 
 #[inline]
 fn unpack_bits_61(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 53)
-        | (((bytes[1]) as u64) << 45)
-        | (((bytes[2]) as u64) << 37)
-        | (((bytes[3]) as u64) << 29)
-        | (((bytes[4]) as u64) << 21)
-        | (((bytes[5]) as u64) << 13)
-        | (((bytes[6]) as u64) << 5)
+    values[0] = ((bytes[0] as u64) << 53)
+        | ((bytes[1] as u64) << 45)
+        | ((bytes[2] as u64) << 37)
+        | ((bytes[3] as u64) << 29)
+        | ((bytes[4] as u64) << 21)
+        | ((bytes[5] as u64) << 13)
+        | ((bytes[6] as u64) << 5)
         | (((bytes[7] >> 3) & 0x1f) as u64);
     values[1] = ((((bytes[7]) & 0x7) as u64) << 58)
-        | (((bytes[8]) as u64) << 50)
-        | (((bytes[9]) as u64) << 42)
-        | (((bytes[10]) as u64) << 34)
-        | (((bytes[11]) as u64) << 26)
-        | (((bytes[12]) as u64) << 18)
-        | (((bytes[13]) as u64) << 10)
-        | (((bytes[14]) as u64) << 2)
+        | ((bytes[8] as u64) << 50)
+        | ((bytes[9] as u64) << 42)
+        | ((bytes[10] as u64) << 34)
+        | ((bytes[11] as u64) << 26)
+        | ((bytes[12] as u64) << 18)
+        | ((bytes[13] as u64) << 10)
+        | ((bytes[14] as u64) << 2)
         | (((bytes[15] >> 6) & 0x3) as u64);
     values[2] = ((((bytes[15]) & 0x3f) as u64) << 55)
-        | (((bytes[16]) as u64) << 47)
-        | (((bytes[17]) as u64) << 39)
-        | (((bytes[18]) as u64) << 31)
-        | (((bytes[19]) as u64) << 23)
-        | (((bytes[20]) as u64) << 15)
-        | (((bytes[21]) as u64) << 7)
+        | ((bytes[16] as u64) << 47)
+        | ((bytes[17] as u64) << 39)
+        | ((bytes[18] as u64) << 31)
+        | ((bytes[19] as u64) << 23)
+        | ((bytes[20] as u64) << 15)
+        | ((bytes[21] as u64) << 7)
         | (((bytes[22] >> 1) & 0x7f) as u64);
     values[3] = ((((bytes[22]) & 0x1) as u64) << 60)
-        | (((bytes[23]) as u64) << 52)
-        | (((bytes[24]) as u64) << 44)
-        | (((bytes[25]) as u64) << 36)
-        | (((bytes[26]) as u64) << 28)
-        | (((bytes[27]) as u64) << 20)
-        | (((bytes[28]) as u64) << 12)
-        | (((bytes[29]) as u64) << 4)
+        | ((bytes[23] as u64) << 52)
+        | ((bytes[24] as u64) << 44)
+        | ((bytes[25] as u64) << 36)
+        | ((bytes[26] as u64) << 28)
+        | ((bytes[27] as u64) << 20)
+        | ((bytes[28] as u64) << 12)
+        | ((bytes[29] as u64) << 4)
         | (((bytes[30] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[30]) & 0xf) as u64) << 57)
-        | (((bytes[31]) as u64) << 49)
-        | (((bytes[32]) as u64) << 41)
-        | (((bytes[33]) as u64) << 33)
-        | (((bytes[34]) as u64) << 25)
-        | (((bytes[35]) as u64) << 17)
-        | (((bytes[36]) as u64) << 9)
-        | (((bytes[37]) as u64) << 1)
+        | ((bytes[31] as u64) << 49)
+        | ((bytes[32] as u64) << 41)
+        | ((bytes[33] as u64) << 33)
+        | ((bytes[34] as u64) << 25)
+        | ((bytes[35] as u64) << 17)
+        | ((bytes[36] as u64) << 9)
+        | ((bytes[37] as u64) << 1)
         | (((bytes[38] >> 7) & 0x1) as u64);
     values[5] = ((((bytes[38]) & 0x7f) as u64) << 54)
-        | (((bytes[39]) as u64) << 46)
-        | (((bytes[40]) as u64) << 38)
-        | (((bytes[41]) as u64) << 30)
-        | (((bytes[42]) as u64) << 22)
-        | (((bytes[43]) as u64) << 14)
-        | (((bytes[44]) as u64) << 6)
+        | ((bytes[39] as u64) << 46)
+        | ((bytes[40] as u64) << 38)
+        | ((bytes[41] as u64) << 30)
+        | ((bytes[42] as u64) << 22)
+        | ((bytes[43] as u64) << 14)
+        | ((bytes[44] as u64) << 6)
         | (((bytes[45] >> 2) & 0x3f) as u64);
     values[6] = ((((bytes[45]) & 0x3) as u64) << 59)
-        | (((bytes[46]) as u64) << 51)
-        | (((bytes[47]) as u64) << 43)
-        | (((bytes[48]) as u64) << 35)
-        | (((bytes[49]) as u64) << 27)
-        | (((bytes[50]) as u64) << 19)
-        | (((bytes[51]) as u64) << 11)
-        | (((bytes[52]) as u64) << 3)
+        | ((bytes[46] as u64) << 51)
+        | ((bytes[47] as u64) << 43)
+        | ((bytes[48] as u64) << 35)
+        | ((bytes[49] as u64) << 27)
+        | ((bytes[50] as u64) << 19)
+        | ((bytes[51] as u64) << 11)
+        | ((bytes[52] as u64) << 3)
         | (((bytes[53] >> 5) & 0x7) as u64);
     values[7] = ((((bytes[53]) & 0x1f) as u64) << 56)
-        | (((bytes[54]) as u64) << 48)
-        | (((bytes[55]) as u64) << 40)
-        | (((bytes[56]) as u64) << 32)
-        | (((bytes[57]) as u64) << 24)
-        | (((bytes[58]) as u64) << 16)
-        | (((bytes[59]) as u64) << 8)
-        | ((bytes[60]) as u64);
+        | ((bytes[54] as u64) << 48)
+        | ((bytes[55] as u64) << 40)
+        | ((bytes[56] as u64) << 32)
+        | ((bytes[57] as u64) << 24)
+        | ((bytes[58] as u64) << 16)
+        | ((bytes[59] as u64) << 8)
+        | (bytes[60] as u64);
 }
 
 #[inline]
 fn unpack_bits_62(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 54)
-        | (((bytes[1]) as u64) << 46)
-        | (((bytes[2]) as u64) << 38)
-        | (((bytes[3]) as u64) << 30)
-        | (((bytes[4]) as u64) << 22)
-        | (((bytes[5]) as u64) << 14)
-        | (((bytes[6]) as u64) << 6)
+    values[0] = ((bytes[0] as u64) << 54)
+        | ((bytes[1] as u64) << 46)
+        | ((bytes[2] as u64) << 38)
+        | ((bytes[3] as u64) << 30)
+        | ((bytes[4] as u64) << 22)
+        | ((bytes[5] as u64) << 14)
+        | ((bytes[6] as u64) << 6)
         | (((bytes[7] >> 2) & 0x3f) as u64);
     values[1] = ((((bytes[7]) & 0x3) as u64) << 60)
-        | (((bytes[8]) as u64) << 52)
-        | (((bytes[9]) as u64) << 44)
-        | (((bytes[10]) as u64) << 36)
-        | (((bytes[11]) as u64) << 28)
-        | (((bytes[12]) as u64) << 20)
-        | (((bytes[13]) as u64) << 12)
-        | (((bytes[14]) as u64) << 4)
+        | ((bytes[8] as u64) << 52)
+        | ((bytes[9] as u64) << 44)
+        | ((bytes[10] as u64) << 36)
+        | ((bytes[11] as u64) << 28)
+        | ((bytes[12] as u64) << 20)
+        | ((bytes[13] as u64) << 12)
+        | ((bytes[14] as u64) << 4)
         | (((bytes[15] >> 4) & 0xf) as u64);
     values[2] = ((((bytes[15]) & 0xf) as u64) << 58)
-        | (((bytes[16]) as u64) << 50)
-        | (((bytes[17]) as u64) << 42)
-        | (((bytes[18]) as u64) << 34)
-        | (((bytes[19]) as u64) << 26)
-        | (((bytes[20]) as u64) << 18)
-        | (((bytes[21]) as u64) << 10)
-        | (((bytes[22]) as u64) << 2)
+        | ((bytes[16] as u64) << 50)
+        | ((bytes[17] as u64) << 42)
+        | ((bytes[18] as u64) << 34)
+        | ((bytes[19] as u64) << 26)
+        | ((bytes[20] as u64) << 18)
+        | ((bytes[21] as u64) << 10)
+        | ((bytes[22] as u64) << 2)
         | (((bytes[23] >> 6) & 0x3) as u64);
     values[3] = ((((bytes[23]) & 0x3f) as u64) << 56)
-        | (((bytes[24]) as u64) << 48)
-        | (((bytes[25]) as u64) << 40)
-        | (((bytes[26]) as u64) << 32)
-        | (((bytes[27]) as u64) << 24)
-        | (((bytes[28]) as u64) << 16)
-        | (((bytes[29]) as u64) << 8)
-        | ((bytes[30]) as u64);
-    values[4] = (((bytes[31]) as u64) << 54)
-        | (((bytes[32]) as u64) << 46)
-        | (((bytes[33]) as u64) << 38)
-        | (((bytes[34]) as u64) << 30)
-        | (((bytes[35]) as u64) << 22)
-        | (((bytes[36]) as u64) << 14)
-        | (((bytes[37]) as u64) << 6)
+        | ((bytes[24] as u64) << 48)
+        | ((bytes[25] as u64) << 40)
+        | ((bytes[26] as u64) << 32)
+        | ((bytes[27] as u64) << 24)
+        | ((bytes[28] as u64) << 16)
+        | ((bytes[29] as u64) << 8)
+        | (bytes[30] as u64);
+    values[4] = ((bytes[31] as u64) << 54)
+        | ((bytes[32] as u64) << 46)
+        | ((bytes[33] as u64) << 38)
+        | ((bytes[34] as u64) << 30)
+        | ((bytes[35] as u64) << 22)
+        | ((bytes[36] as u64) << 14)
+        | ((bytes[37] as u64) << 6)
         | (((bytes[38] >> 2) & 0x3f) as u64);
     values[5] = ((((bytes[38]) & 0x3) as u64) << 60)
-        | (((bytes[39]) as u64) << 52)
-        | (((bytes[40]) as u64) << 44)
-        | (((bytes[41]) as u64) << 36)
-        | (((bytes[42]) as u64) << 28)
-        | (((bytes[43]) as u64) << 20)
-        | (((bytes[44]) as u64) << 12)
-        | (((bytes[45]) as u64) << 4)
+        | ((bytes[39] as u64) << 52)
+        | ((bytes[40] as u64) << 44)
+        | ((bytes[41] as u64) << 36)
+        | ((bytes[42] as u64) << 28)
+        | ((bytes[43] as u64) << 20)
+        | ((bytes[44] as u64) << 12)
+        | ((bytes[45] as u64) << 4)
         | (((bytes[46] >> 4) & 0xf) as u64);
     values[6] = ((((bytes[46]) & 0xf) as u64) << 58)
-        | (((bytes[47]) as u64) << 50)
-        | (((bytes[48]) as u64) << 42)
-        | (((bytes[49]) as u64) << 34)
-        | (((bytes[50]) as u64) << 26)
-        | (((bytes[51]) as u64) << 18)
-        | (((bytes[52]) as u64) << 10)
-        | (((bytes[53]) as u64) << 2)
+        | ((bytes[47] as u64) << 50)
+        | ((bytes[48] as u64) << 42)
+        | ((bytes[49] as u64) << 34)
+        | ((bytes[50] as u64) << 26)
+        | ((bytes[51] as u64) << 18)
+        | ((bytes[52] as u64) << 10)
+        | ((bytes[53] as u64) << 2)
         | (((bytes[54] >> 6) & 0x3) as u64);
     values[7] = ((((bytes[54]) & 0x3f) as u64) << 56)
-        | (((bytes[55]) as u64) << 48)
-        | (((bytes[56]) as u64) << 40)
-        | (((bytes[57]) as u64) << 32)
-        | (((bytes[58]) as u64) << 24)
-        | (((bytes[59]) as u64) << 16)
-        | (((bytes[60]) as u64) << 8)
-        | ((bytes[61]) as u64);
+        | ((bytes[55] as u64) << 48)
+        | ((bytes[56] as u64) << 40)
+        | ((bytes[57] as u64) << 32)
+        | ((bytes[58] as u64) << 24)
+        | ((bytes[59] as u64) << 16)
+        | ((bytes[60] as u64) << 8)
+        | (bytes[61] as u64);
 }
 
 #[inline]
 fn unpack_bits_63(values: &mut [u64], bytes: &[u8]) {
-    values[0] = (((bytes[0]) as u64) << 55)
-        | (((bytes[1]) as u64) << 47)
-        | (((bytes[2]) as u64) << 39)
-        | (((bytes[3]) as u64) << 31)
-        | (((bytes[4]) as u64) << 23)
-        | (((bytes[5]) as u64) << 15)
-        | (((bytes[6]) as u64) << 7)
+    values[0] = ((bytes[0] as u64) << 55)
+        | ((bytes[1] as u64) << 47)
+        | ((bytes[2] as u64) << 39)
+        | ((bytes[3] as u64) << 31)
+        | ((bytes[4] as u64) << 23)
+        | ((bytes[5] as u64) << 15)
+        | ((bytes[6] as u64) << 7)
         | (((bytes[7] >> 1) & 0x7f) as u64);
     values[1] = ((((bytes[7]) & 0x1) as u64) << 62)
-        | (((bytes[8]) as u64) << 54)
-        | (((bytes[9]) as u64) << 46)
-        | (((bytes[10]) as u64) << 38)
-        | (((bytes[11]) as u64) << 30)
-        | (((bytes[12]) as u64) << 22)
-        | (((bytes[13]) as u64) << 14)
-        | (((bytes[14]) as u64) << 6)
+        | ((bytes[8] as u64) << 54)
+        | ((bytes[9] as u64) << 46)
+        | ((bytes[10] as u64) << 38)
+        | ((bytes[11] as u64) << 30)
+        | ((bytes[12] as u64) << 22)
+        | ((bytes[13] as u64) << 14)
+        | ((bytes[14] as u64) << 6)
         | (((bytes[15] >> 2) & 0x3f) as u64);
     values[2] = ((((bytes[15]) & 0x3) as u64) << 61)
-        | (((bytes[16]) as u64) << 53)
-        | (((bytes[17]) as u64) << 45)
-        | (((bytes[18]) as u64) << 37)
-        | (((bytes[19]) as u64) << 29)
-        | (((bytes[20]) as u64) << 21)
-        | (((bytes[21]) as u64) << 13)
-        | (((bytes[22]) as u64) << 5)
+        | ((bytes[16] as u64) << 53)
+        | ((bytes[17] as u64) << 45)
+        | ((bytes[18] as u64) << 37)
+        | ((bytes[19] as u64) << 29)
+        | ((bytes[20] as u64) << 21)
+        | ((bytes[21] as u64) << 13)
+        | ((bytes[22] as u64) << 5)
         | (((bytes[23] >> 3) & 0x1f) as u64);
     values[3] = ((((bytes[23]) & 0x7) as u64) << 60)
-        | (((bytes[24]) as u64) << 52)
-        | (((bytes[25]) as u64) << 44)
-        | (((bytes[26]) as u64) << 36)
-        | (((bytes[27]) as u64) << 28)
-        | (((bytes[28]) as u64) << 20)
-        | (((bytes[29]) as u64) << 12)
-        | (((bytes[30]) as u64) << 4)
+        | ((bytes[24] as u64) << 52)
+        | ((bytes[25] as u64) << 44)
+        | ((bytes[26] as u64) << 36)
+        | ((bytes[27] as u64) << 28)
+        | ((bytes[28] as u64) << 20)
+        | ((bytes[29] as u64) << 12)
+        | ((bytes[30] as u64) << 4)
         | (((bytes[31] >> 4) & 0xf) as u64);
     values[4] = ((((bytes[31]) & 0xf) as u64) << 59)
-        | (((bytes[32]) as u64) << 51)
-        | (((bytes[33]) as u64) << 43)
-        | (((bytes[34]) as u64) << 35)
-        | (((bytes[35]) as u64) << 27)
-        | (((bytes[36]) as u64) << 19)
-        | (((bytes[37]) as u64) << 11)
-        | (((bytes[38]) as u64) << 3)
+        | ((bytes[32] as u64) << 51)
+        | ((bytes[33] as u64) << 43)
+        | ((bytes[34] as u64) << 35)
+        | ((bytes[35] as u64) << 27)
+        | ((bytes[36] as u64) << 19)
+        | ((bytes[37] as u64) << 11)
+        | ((bytes[38] as u64) << 3)
         | (((bytes[39] >> 5) & 0x7) as u64);
     values[5] = ((((bytes[39]) & 0x1f) as u64) << 58)
-        | (((bytes[40]) as u64) << 50)
-        | (((bytes[41]) as u64) << 42)
-        | (((bytes[42]) as u64) << 34)
-        | (((bytes[43]) as u64) << 26)
-        | (((bytes[44]) as u64) << 18)
-        | (((bytes[45]) as u64) << 10)
-        | (((bytes[46]) as u64) << 2)
+        | ((bytes[40] as u64) << 50)
+        | ((bytes[41] as u64) << 42)
+        | ((bytes[42] as u64) << 34)
+        | ((bytes[43] as u64) << 26)
+        | ((bytes[44] as u64) << 18)
+        | ((bytes[45] as u64) << 10)
+        | ((bytes[46] as u64) << 2)
         | (((bytes[47] >> 6) & 0x3) as u64);
     values[6] = ((((bytes[47]) & 0x3f) as u64) << 57)
-        | (((bytes[48]) as u64) << 49)
-        | (((bytes[49]) as u64) << 41)
-        | (((bytes[50]) as u64) << 33)
-        | (((bytes[51]) as u64) << 25)
-        | (((bytes[52]) as u64) << 17)
-        | (((bytes[53]) as u64) << 9)
-        | (((bytes[54]) as u64) << 1)
+        | ((bytes[48] as u64) << 49)
+        | ((bytes[49] as u64) << 41)
+        | ((bytes[50] as u64) << 33)
+        | ((bytes[51] as u64) << 25)
+        | ((bytes[52] as u64) << 17)
+        | ((bytes[53] as u64) << 9)
+        | ((bytes[54] as u64) << 1)
         | (((bytes[55] >> 7) & 0x1) as u64);
     values[7] = ((((bytes[55]) & 0x7f) as u64) << 56)
-        | (((bytes[56]) as u64) << 48)
-        | (((bytes[57]) as u64) << 40)
-        | (((bytes[58]) as u64) << 32)
-        | (((bytes[59]) as u64) << 24)
-        | (((bytes[60]) as u64) << 16)
-        | (((bytes[61]) as u64) << 8)
-        | ((bytes[62]) as u64);
+        | ((bytes[56] as u64) << 48)
+        | ((bytes[57] as u64) << 40)
+        | ((bytes[58] as u64) << 32)
+        | ((bytes[59] as u64) << 24)
+        | ((bytes[60] as u64) << 16)
+        | ((bytes[61] as u64) << 8)
+        | (bytes[62] as u64);
 }
 
 /// Packs a block of `BLOCK_WIDTH` values using fully-expanded fixed-width bit packing.
@@ -4975,7 +4965,7 @@ fn unpack_bits_63(values: &mut [u64], bytes: &[u8]) {
 /// * Panics if `values.len()` is not equal to `BLOCK_WIDTH`.
 /// * Panics if `bits` is not in the range `1..=63`.
 /// * Panics if `bytes.len()` is less than `bits`.
-pub(crate) fn pack_bits_block(values: &[u64], bytes: &mut [u8], bits: u8) {
+pub(super) fn pack_bits_block(values: &[u64], bytes: &mut [u8], bits: u8) {
     assert_eq!(values.len(), BLOCK_WIDTH, "values length must be 8");
     assert!(
         (1..=63).contains(&bits),
@@ -5058,7 +5048,7 @@ pub(crate) fn pack_bits_block(values: &[u64], bytes: &mut [u8], bits: u8) {
 /// * Panics if `values.len()` is not equal to `BLOCK_WIDTH`.
 /// * Panics if `bits` is not in the range `1..=63`.
 /// * Panics if `bytes.len()` is less than `bits`.
-pub(crate) fn unpack_bits_block(values: &mut [u64], bytes: &[u8], bits: u8) {
+pub(super) fn unpack_bits_block(values: &mut [u64], bytes: &[u8], bits: u8) {
     assert_eq!(values.len(), BLOCK_WIDTH, "values length must be 8");
     assert!(
         (1..=63).contains(&bits),
@@ -5139,7 +5129,7 @@ mod tests {
     use super::*;
 
     // inverse golden ratio (0.618.. of max uint64_t)
-    const IGOLDEN64: u64 = 0x9e37_79b9_7f4a_7c13;
+    const INVERSE_GOLDEN_RATIO: u64 = 0x9e37_79b9_7f4a_7c13;
 
     #[test]
     fn pack_unpack_bits() {
@@ -5151,10 +5141,10 @@ mod tests {
                 let mut input = vec![0u64; n];
                 for item in &mut input {
                     *item = value & mask;
-                    value = value.wrapping_add(IGOLDEN64);
+                    value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
                 }
 
-                let mut bytes = vec![0u8; n * std::mem::size_of::<u64>()];
+                let mut bytes = vec![0u8; n * size_of::<u64>()];
                 let mut packer = BitPacker::new(&mut bytes);
                 for i in 0..n {
                     packer.pack_value(input[i], bits);
@@ -5182,7 +5172,7 @@ mod tests {
                 let mut input = vec![0u64; BLOCK_WIDTH];
                 for item in &mut input {
                     *item = value & mask;
-                    value = value.wrapping_add(IGOLDEN64);
+                    value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
                 }
 
                 let mut bytes = vec![0u8; bits as usize];
@@ -5207,7 +5197,7 @@ mod tests {
                 let mut input = vec![0u64; BLOCK_WIDTH];
                 for item in &mut input {
                     *item = value & mask;
-                    value = value.wrapping_add(IGOLDEN64);
+                    value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
                 }
 
                 let mut bytes = vec![0u8; bits as usize];
@@ -5235,7 +5225,7 @@ mod tests {
                 let mut input = vec![0u64; BLOCK_WIDTH];
                 for item in &mut input {
                     *item = value & mask;
-                    value = value.wrapping_add(IGOLDEN64);
+                    value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
                 }
 
                 let mut bytes = vec![0u8; bits as usize];
@@ -5261,10 +5251,10 @@ mod tests {
         let mut input = vec![0u64; n];
         for item in &mut input {
             *item = value;
-            value = value.wrapping_add(IGOLDEN64);
+            value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
         }
 
-        let mut bytes = vec![0u8; n * std::mem::size_of::<u64>()];
+        let mut bytes = vec![0u8; n * size_of::<u64>()];
         let mut packer = BitPacker::new(&mut bytes);
         for &v in &input {
             packer.pack_value(v, 64);
@@ -5311,7 +5301,7 @@ mod tests {
             let mut input = [0u64; 8];
             for item in &mut input {
                 *item = value & mask;
-                value = value.wrapping_add(IGOLDEN64);
+                value = value.wrapping_add(INVERSE_GOLDEN_RATIO);
             }
 
             let mut bytes = vec![0u8; bits as usize];
diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index ede0788..cf55482 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -39,7 +39,7 @@ const STRIDE_MASK: u64 = (1 << STRIDE_HASH_BITS) - 1;
 ///   exceeds the threshold, it will rebuild the table: only keep the min 2^lg_nom_size entries and
 ///   update the theta to the k-th smallest entry.
 #[derive(Debug)]
-pub(crate) struct ThetaHashTable {
+pub(super) struct ThetaHashTable {
     lg_cur_size: u8,
     lg_nom_size: u8,
     lg_max_size: u8,
diff --git a/datasketches/src/theta/serialization.rs b/datasketches/src/theta/serialization.rs
index 0cd6cf7..ad54307 100644
--- a/datasketches/src/theta/serialization.rs
+++ b/datasketches/src/theta/serialization.rs
@@ -17,14 +17,14 @@
 
 //! Binary serialization format constants for Theta sketches.
 
-pub(crate) const UNCOMPRESSED_SERIAL_VERSION: u8 = 3;
-pub(crate) const COMPRESSED_SERIAL_VERSION: u8 = 4;
+pub(super) const UNCOMPRESSED_SERIAL_VERSION: u8 = 3;
+pub(super) const COMPRESSED_SERIAL_VERSION: u8 = 4;
 
-pub(crate) const V2_PREAMBLE_EMPTY: u8 = 1;
-pub(crate) const V2_PREAMBLE_PRECISE: u8 = 2;
-pub(crate) const V2_PREAMBLE_ESTIMATE: u8 = 3;
+pub(super) const V2_PREAMBLE_EMPTY: u8 = 1;
+pub(super) const V2_PREAMBLE_PRECISE: u8 = 2;
+pub(super) const V2_PREAMBLE_ESTIMATE: u8 = 3;
 
-pub(crate) const FLAGS_IS_READ_ONLY: u8 = 1 << 1;
-pub(crate) const FLAGS_IS_EMPTY: u8 = 1 << 2;
-pub(crate) const FLAGS_IS_COMPACT: u8 = 1 << 3;
-pub(crate) const FLAGS_IS_ORDERED: u8 = 1 << 4;
+pub(super) const FLAGS_IS_READ_ONLY: u8 = 1 << 1;
+pub(super) const FLAGS_IS_EMPTY: u8 = 1 << 2;
+pub(super) const FLAGS_IS_COMPACT: u8 = 1 << 3;
+pub(super) const FLAGS_IS_ORDERED: u8 = 1 << 4;
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index d38e43b..1ef430a 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -365,7 +365,7 @@ pub struct CompactThetaSketch {
 }
 
 impl CompactThetaSketch {
-    pub(crate) fn from_parts(
+    pub(super) fn from_parts(
         entries: Vec<u64>,
         theta: u64,
         seed_hash: u16,

From 2bc08c74ba00ca0df955cf05edd2a9e06743513e Mon Sep 17 00:00:00 2001
From: tison <wander4096@gmail.com>
Date: Tue, 17 Mar 2026 08:39:30 +0800
Subject: [PATCH 7/8] human review

Signed-off-by: tison <wander4096@gmail.com>
---
 datasketches/src/theta/hash_table.rs   |  8 ++++++--
 datasketches/src/theta/intersection.rs | 11 ++++++-----
 datasketches/src/theta/sketch.rs       | 12 +++++++++++-
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index cf55482..7658ff3 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -47,8 +47,12 @@ pub(super) struct ThetaHashTable {
     sampling_probability: f32,
     hash_seed: u64,
 
-    // Logical emptiness of the source set. This can be false even when `num_retained` is 0 (e.g.
-    // all updates screened by theta).
+    // Logical emptiness of the source set.
+    //
+    // * `false` if any update has been attempted (even if screened by theta)
+    // * `true` if no updates have been attempted.
+    //
+    // This can be false even when `num_retained` is 0.
     is_empty: bool,
 
     theta: u64,
diff --git a/datasketches/src/theta/intersection.rs b/datasketches/src/theta/intersection.rs
index 145fdb7..23e9fc6 100644
--- a/datasketches/src/theta/intersection.rs
+++ b/datasketches/src/theta/intersection.rs
@@ -86,14 +86,15 @@ impl ThetaIntersection {
             )));
         }
 
-        self.table
-            .set_empty(self.table.is_empty() || sketch.is_empty());
-        let theta = if self.table.is_empty() {
+        if sketch.is_empty() {
+            self.table.set_empty(true);
+        }
+
+        self.table.set_theta(if self.table.is_empty() {
             MAX_THETA
         } else {
             self.table.theta().min(sketch.theta64())
-        };
-        self.table.set_theta(theta);
+        });
 
         if self.is_valid && self.table.num_retained() == 0 {
             return Ok(());
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index 1ef430a..dd5d30e 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -49,11 +49,21 @@ use crate::theta::serialization::V2_PREAMBLE_EMPTY;
 use crate::theta::serialization::V2_PREAMBLE_ESTIMATE;
 use crate::theta::serialization::V2_PREAMBLE_PRECISE;
 
+mod private {
+    use super::*;
+
+    // Sealed trait to prevent external implementations of ThetaSketchView.
+    pub trait Sealed {}
+
+    impl Sealed for ThetaSketch {}
+    impl Sealed for CompactThetaSketch {}
+}
+
 /// Read-only view for Theta sketches.
 ///
 /// This trait provides a unified input abstraction for APIs that can accept either
 /// mutable [`ThetaSketch`] or immutable [`CompactThetaSketch`].
-pub trait ThetaSketchView {
+pub trait ThetaSketchView: private::Sealed {
     /// Returns the 16-bit seed hash.
     fn seed_hash(&self) -> u16;
 

From f16767b0fbe4f7a7ea03bb21daba733c2d511b01 Mon Sep 17 00:00:00 2001
From: tison <wander4096@gmail.com>
Date: Tue, 17 Mar 2026 08:47:19 +0800
Subject: [PATCH 8/8] address comments

Signed-off-by: tison <wander4096@gmail.com>
---
 datasketches/src/theta/hash_table.rs   | 3 ++-
 datasketches/src/theta/intersection.rs | 2 +-
 datasketches/src/theta/sketch.rs       | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index 7658ff3..fb8fec9 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -120,7 +120,7 @@ impl ThetaHashTable {
     }
 
     /// Hash a value with the table seed and return the hash.
-    pub fn hash<T: Hash>(&self, value: T) -> u64 {
+    fn hash<T: Hash>(&self, value: T) -> u64 {
         let mut hasher = MurmurHash3X64128::with_seed(self.hash_seed);
         value.hash(&mut hasher);
         let (h1, _) = hasher.finish128();
@@ -456,6 +456,7 @@ mod tests {
         table.theta = 0;
         assert!(!table.try_insert("screened"));
         assert_eq!(table.num_retained(), 1);
+        assert!(!table.is_empty());
     }
 
     #[test]
diff --git a/datasketches/src/theta/intersection.rs b/datasketches/src/theta/intersection.rs
index 23e9fc6..85d2eb7 100644
--- a/datasketches/src/theta/intersection.rs
+++ b/datasketches/src/theta/intersection.rs
@@ -219,7 +219,7 @@ impl ThetaIntersection {
             self.is_valid,
             "ThetaIntersection::result() called before first update()"
         );
-        let mut hashes = self.table.iter().collect::<Vec<_>>();
+        let mut hashes: Vec<u64> = self.table.iter().collect();
         if ordered {
             hashes.sort_unstable();
         }
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index dd5d30e..c304784 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -999,7 +999,7 @@ impl ThetaSketchBuilder {
     ///
     /// # Panics
     ///
-    /// Panics if p is not in range (0.0, 1.0]
+    /// Panics if p is not in range `(0.0, 1.0]`
     ///
     /// # Examples
     ///