diff --git a/cpp/src/arrow/util/bit_stream_utils_internal.h b/cpp/src/arrow/util/bit_stream_utils_internal.h
index 376de56a9af..f77eabf958f 100644
--- a/cpp/src/arrow/util/bit_stream_utils_internal.h
+++ b/cpp/src/arrow/util/bit_stream_utils_internal.h
@@ -273,14 +273,19 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
     batch_size = static_cast<int>(remaining_bits / num_bits);
   }
 
+  const ::arrow::internal::UnpackOptions opts{
+      /* .batch_size= */ batch_size,
+      /* .bit_width= */ num_bits,
+      /* .bit_offset= */ bit_offset_,
+      /* .max_read_bytes= */ max_bytes_ - byte_offset_,
+  };
+
   if constexpr (std::is_same_v<T, bool>) {
-    ::arrow::internal::unpack(buffer_ + byte_offset_, v, batch_size, num_bits,
-                              bit_offset_);
+    ::arrow::internal::unpack(buffer_ + byte_offset_, v, opts);
 
   } else {
     ::arrow::internal::unpack(buffer_ + byte_offset_,
-                              reinterpret_cast<std::make_unsigned_t<T>*>(v), batch_size,
-                              num_bits, bit_offset_);
+                              reinterpret_cast<std::make_unsigned_t<T>*>(v), opts);
   }
 
   Advance(batch_size * num_bits);
diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
index fdb1c5a52ac..a39f3610085 100644
--- a/cpp/src/arrow/util/bpacking.cc
+++ b/cpp/src/arrow/util/bpacking.cc
@@ -17,7 +17,6 @@
 
 #include <array>
 
-#include "arrow/util/bpacking_dispatch_internal.h"
 #include "arrow/util/bpacking_internal.h"
 #include "arrow/util/bpacking_scalar_internal.h"
 #include "arrow/util/bpacking_simd_internal.h"
@@ -34,9 +33,11 @@ struct UnpackDynamicFunction {
 
   static constexpr auto implementations() {
     return std::array {
-      // Current SIMD unpack algorithm works terribly on SSE4.2 due to lack of variable
-      // rhsift and poor xsimd fallback.
+#if defined(ARROW_HAVE_SSE4_2)
+      Implementation{DispatchLevel::NONE, &unpack_sse4_2<Uint>},
+#else
       Implementation{DispatchLevel::NONE, &unpack_scalar<Uint>},
+#endif
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
           Implementation{DispatchLevel::AVX2, &unpack_avx2<Uint>},
 #endif
@@ -50,19 +51,19 @@ struct UnpackDynamicFunction {
 }  // namespace
 
 template <typename Uint>
-void unpack(const uint8_t* in, Uint* out, int batch_size, int num_bits, int bit_offset) {
+void unpack(const uint8_t* in, Uint* out, const UnpackOptions& opts) {
 #if defined(ARROW_HAVE_NEON)
-  return unpack_neon(in, out, batch_size, num_bits, bit_offset);
+  return unpack_neon(in, out, opts);
 #else
   static DynamicDispatch<UnpackDynamicFunction<Uint> > dispatch;
-  return dispatch.func(in, out, batch_size, num_bits, bit_offset);
+  return dispatch.func(in, out, opts);
 #endif
 }
 
-template void unpack<bool>(const uint8_t*, bool*, int, int, int);
-template void unpack<uint8_t>(const uint8_t*, uint8_t*, int, int, int);
-template void unpack<uint16_t>(const uint8_t*, uint16_t*, int, int, int);
-template void unpack<uint32_t>(const uint8_t*, uint32_t*, int, int, int);
-template void unpack<uint64_t>(const uint8_t*, uint64_t*, int, int, int);
+template void unpack<bool>(const uint8_t*, bool*, const UnpackOptions&);
+template void unpack<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&);
+template void unpack<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
+template void unpack<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
+template void unpack<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_benchmark.cc b/cpp/src/arrow/util/bpacking_benchmark.cc
index 7094656eeef..69ce84c37f3 100644
--- a/cpp/src/arrow/util/bpacking_benchmark.cc
+++ b/cpp/src/arrow/util/bpacking_benchmark.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <memory>
 #include <stdexcept>
 #include <vector>
 
@@ -33,7 +34,7 @@ namespace arrow::internal {
 namespace {
 
 template <typename Int>
-using UnpackFunc = void (*)(const uint8_t*, Int*, int, int, int);
+using UnpackFunc = void (*)(const uint8_t*, Int*, const UnpackOptions&);
 
 /// Get the number of bytes associate with a packing.
 constexpr int32_t GetNumBytes(int32_t num_values, int32_t bit_width) {
@@ -86,33 +87,62 @@ void BM_Unpack(benchmark::State& state, bool aligned, UnpackFunc<Int> unpack, bo
   const uint8_t* packed_ptr =
       GetNextAlignedByte(packed.data(), sizeof(Int)) + (aligned ? 0 : 1);
 
-  std::vector<Int> unpacked(num_values, 0);
+  auto unpacked = std::make_unique<Int[]>(num_values);
+
+  const ::arrow::internal::UnpackOptions opts{
+      /* .batch_size= */ num_values,
+      /* .bit_width= */ bit_width,
+      /* .bit_offset= */ 0,
+      /* .max_read_bytes= */ -1,
+  };
 
   for (auto _ : state) {
-    unpack(packed_ptr, unpacked.data(), num_values, bit_width, /* bit_offset = */ 0);
+    unpack(packed_ptr, unpacked.get(), opts);
     benchmark::ClobberMemory();
   }
   state.SetItemsProcessed(num_values * state.iterations());
 }
 
-constexpr int32_t kMinRange = 64;
-constexpr int32_t kMaxRange = 32768;
+/// Currently, the minimum unpack SIMD kernel size is 32 and the bit packing encoder will
+/// not emit runs larger than 512 (though other implementation might), so we biased the
+/// benchmarks towards a rather small scale.
+static const auto kNumValuesRange = benchmark::CreateRange(32, 512, 2);
+constexpr std::initializer_list<int64_t> kBitWidths8 = {1, 2, 8};
 constexpr std::initializer_list<int64_t> kBitWidths16 = {1, 2, 8, 13};
 constexpr std::initializer_list<int64_t> kBitWidths32 = {1, 2, 8, 20};
 constexpr std::initializer_list<int64_t> kBitWidths64 = {1, 2, 8, 20, 47};
+
+static const std::vector<std::vector<int64_t>> kBitWidthsNumValuesBool = {
+    {0, 1},
+    kNumValuesRange,
+};
+static const std::vector<std::vector<int64_t>> kBitWidthsNumValues8 = {
+    kBitWidths8,
+    kNumValuesRange,
+};
 static const std::vector<std::vector<int64_t>> kBitWidthsNumValues16 = {
     kBitWidths16,
-    benchmark::CreateRange(kMinRange, kMaxRange, /*multi=*/32),
+    kNumValuesRange,
 };
 static const std::vector<std::vector<int64_t>> kBitWidthsNumValues32 = {
     kBitWidths32,
-    benchmark::CreateRange(kMinRange, kMaxRange, /*multi=*/32),
+    kNumValuesRange,
 };
 static const std::vector<std::vector<int64_t>> kBitWidthsNumValues64 = {
     kBitWidths64,
-    benchmark::CreateRange(kMinRange, kMaxRange, /*multi=*/32),
+    kNumValuesRange,
 };
 
+/// Nudge for MSVC template inside BENCHMARK_CAPTURE macro.
+void BM_UnpackBool(benchmark::State& state, bool aligned, UnpackFunc<bool> unpack,
+                   bool skip = false, std::string skip_msg = "") {
+  return BM_Unpack<bool>(state, aligned, unpack, skip, std::move(skip_msg));
+}
+/// Nudge for MSVC template inside BENCHMARK_CAPTURE macro.
+void BM_UnpackUint8(benchmark::State& state, bool aligned, UnpackFunc<uint8_t> unpack,
+                    bool skip = false, std::string skip_msg = "") {
+  return BM_Unpack<uint8_t>(state, aligned, unpack, skip, std::move(skip_msg));
+}
 /// Nudge for MSVC template inside BENCHMARK_CAPTURE macro.
 void BM_UnpackUint16(benchmark::State& state, bool aligned, UnpackFunc<uint16_t> unpack,
                      bool skip = false, std::string skip_msg = "") {
@@ -129,6 +159,10 @@ void BM_UnpackUint64(benchmark::State& state, bool aligned, UnpackFunc<uint64_t>
   return BM_Unpack<uint64_t>(state, aligned, unpack, skip, std::move(skip_msg));
 }
 
+BENCHMARK_CAPTURE(BM_UnpackBool, ScalarUnaligned, false, &unpack_scalar<bool>)
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackUint8, ScalarUnaligned, false, &unpack_scalar<uint8_t>)
+    ->ArgsProduct(kBitWidthsNumValues8);
 BENCHMARK_CAPTURE(BM_UnpackUint16, ScalarUnaligned, false, &unpack_scalar<uint16_t>)
     ->ArgsProduct(kBitWidthsNumValues16);
 BENCHMARK_CAPTURE(BM_UnpackUint32, ScalarUnaligned, false, &unpack_scalar<uint32_t>)
@@ -136,7 +170,28 @@ BENCHMARK_CAPTURE(BM_UnpackUint32, ScalarUnaligned, false, &unpack_scalar<uint32
 BENCHMARK_CAPTURE(BM_UnpackUint64, ScalarUnaligned, false, &unpack_scalar<uint64_t>)
     ->ArgsProduct(kBitWidthsNumValues64);
 
+#if defined(ARROW_HAVE_SSE4_2)
+BENCHMARK_CAPTURE(BM_UnpackBool, Sse42Unaligned, false, &unpack_sse4_2<bool>)
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackUint8, Sse42Unaligned, false, &unpack_sse4_2<uint8_t>)
+    ->ArgsProduct(kBitWidthsNumValues8);
+BENCHMARK_CAPTURE(BM_UnpackUint16, Sse42Unaligned, false, &unpack_sse4_2<uint16_t>)
+    ->ArgsProduct(kBitWidthsNumValues16);
+BENCHMARK_CAPTURE(BM_UnpackUint32, Sse42Unaligned, false, &unpack_sse4_2<uint32_t>)
+    ->ArgsProduct(kBitWidthsNumValues32);
+BENCHMARK_CAPTURE(BM_UnpackUint64, Sse42Unaligned, false, &unpack_sse4_2<uint64_t>)
+    ->ArgsProduct(kBitWidthsNumValues64);
+#endif
+
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
+BENCHMARK_CAPTURE(BM_UnpackBool, Avx2Unaligned, false, &unpack_avx2<bool>,
+                  !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2),
+                  "Avx2 not available")
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackUint8, Avx2Unaligned, false, &unpack_avx2<uint8_t>,
+                  !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2),
+                  "Avx2 not available")
+    ->ArgsProduct(kBitWidthsNumValues8);
 BENCHMARK_CAPTURE(BM_UnpackUint16, Avx2Unaligned, false, &unpack_avx2<uint16_t>,
                   !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2),
                   "Avx2 not available")
@@ -152,6 +207,14 @@ BENCHMARK_CAPTURE(BM_UnpackUint64, Avx2Unaligned, false, &unpack_avx2<uint64_t>,
 #endif
 
 #if defined(ARROW_HAVE_RUNTIME_AVX512)
+BENCHMARK_CAPTURE(BM_UnpackBool, Avx512Unaligned, false, &unpack_avx512<bool>,
+                  !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512),
+                  "Avx512 not available")
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackUint8, Avx512Unaligned, false, &unpack_avx512<uint8_t>,
+                  !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512),
+                  "Avx512 not available")
+    ->ArgsProduct(kBitWidthsNumValues8);
 BENCHMARK_CAPTURE(BM_UnpackUint16, Avx512Unaligned, false, &unpack_avx512<uint16_t>,
                   !CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX512),
                   "Avx512 not available")
@@ -167,6 +230,10 @@ BENCHMARK_CAPTURE(BM_UnpackUint64, Avx512Unaligned, false, &unpack_avx512<uint64
 #endif
 
 #if defined(ARROW_HAVE_NEON)
+BENCHMARK_CAPTURE(BM_UnpackBool, NeonUnaligned, false, &unpack_neon<bool>)
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackUint8, NeonUnaligned, false, &unpack_neon<uint8_t>)
+    ->ArgsProduct(kBitWidthsNumValues8);
 BENCHMARK_CAPTURE(BM_UnpackUint16, NeonUnaligned, false, &unpack_neon<uint16_t>)
     ->ArgsProduct(kBitWidthsNumValues16);
 BENCHMARK_CAPTURE(BM_UnpackUint32, NeonUnaligned, false, &unpack_neon<uint32_t>)
@@ -175,6 +242,16 @@ BENCHMARK_CAPTURE(BM_UnpackUint64, NeonUnaligned, false, &unpack_neon<uint64_t>)
     ->ArgsProduct(kBitWidthsNumValues64);
 #endif
 
+BENCHMARK_CAPTURE(BM_UnpackBool, DynamicAligned, true, &unpack<bool>)
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+BENCHMARK_CAPTURE(BM_UnpackBool, DynamicUnaligned, false, &unpack<bool>)
+    ->ArgsProduct(kBitWidthsNumValuesBool);
+
+BENCHMARK_CAPTURE(BM_UnpackUint8, DynamicAligned, true, &unpack<uint8_t>)
+    ->ArgsProduct(kBitWidthsNumValues8);
+BENCHMARK_CAPTURE(BM_UnpackUint8, DynamicUnaligned, false, &unpack<uint8_t>)
+    ->ArgsProduct(kBitWidthsNumValues8);
+
 BENCHMARK_CAPTURE(BM_UnpackUint16, DynamicAligned, true, &unpack<uint16_t>)
     ->ArgsProduct(kBitWidthsNumValues16);
 BENCHMARK_CAPTURE(BM_UnpackUint16, DynamicUnaligned, false, &unpack<uint16_t>)
diff --git a/cpp/src/arrow/util/bpacking_dispatch_internal.h b/cpp/src/arrow/util/bpacking_dispatch_internal.h
index eed5542808d..509337f0b31 100644
--- a/cpp/src/arrow/util/bpacking_dispatch_internal.h
+++ b/cpp/src/arrow/util/bpacking_dispatch_internal.h
@@ -22,6 +22,7 @@
 #include <type_traits>
 
 #include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
@@ -166,13 +167,26 @@ int unpack_exact(const uint8_t* in, Uint* out, int batch_size, int bit_offset) {
 ///                  fixed amount of values (usually constrained by SIMD batch sizes and
 ///                  byte alignment).
 /// @tparam UnpackedUInt The type in which we unpack the values.
+/// @param batch_size The number of values to unpack.
+/// @param max_read_bytes The maximum size of the input byte array that can be read.
+///                       This is used to safely overread.
+///                       Negative value to deduce from batch_size.
 template <int kPackedBitWidth, template <typename, int> typename Unpacker,
           typename UnpackedUInt>
-void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset) {
+void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_offset,
+                  int max_read_bytes) {
   if constexpr (kPackedBitWidth == 0) {
     // Easy case to handle, simply setting memory to zero.
     return unpack_null(in, out, batch_size);
   } else {
+    // Number of size to read according to batch_size.
+    const int bytes_batch = static_cast<int>(
+        bit_util::BytesForBits(batch_size * kPackedBitWidth + bit_offset));
+    // If specified, max_read_bytes must be greater that the bytes needed to extract the
+    // number of desired values.
+    ARROW_DCHECK(max_read_bytes < 0 || bytes_batch <= max_read_bytes);
+    const uint8_t* in_end = in + (max_read_bytes >= 0 ? max_read_bytes : bytes_batch);
+
     // In case of misalignment, we need to run the prolog until aligned.
     int extracted = unpack_exact<kPackedBitWidth, true>(in, out, batch_size, bit_offset);
     // We either extracted everything or found a alignment
@@ -188,20 +202,29 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
       return unpack_full(in, out, batch_size);
     } else {
       using UnpackerForWidth = Unpacker<UnpackedUInt, kPackedBitWidth>;
+      // Number of values extracted by one iteration of the kernel
       constexpr auto kValuesUnpacked = UnpackerForWidth::kValuesUnpacked;
+      // Number of bytes read, but not necessarily unpacked, by one iteration of the
+      // kernel. This constant prevent reading past buffer end.
+      constexpr auto kBytesRead = UnpackerForWidth::kBytesRead;
+
+      if constexpr (kValuesUnpacked > 0) {
+        const uint8_t* in_last = in_end - kBytesRead;
+        // Running the optimized kernel for batch extraction
+        while ((batch_size >= kValuesUnpacked) && (in <= in_last)) {
+          in = UnpackerForWidth::unpack(in, out);
+          out += kValuesUnpacked;
+          batch_size -= kValuesUnpacked;
+        }
 
-      // Running the optimized kernel for batch extraction
-      const int unpacker_iter_count = batch_size / kValuesUnpacked;
-      for (int i = 0; i < unpacker_iter_count; ++i) {
-        in = UnpackerForWidth::unpack(in, out);
-        out += kValuesUnpacked;
+        // Performance check aking sure we ran the kernel loop as much as possible:
+        // Either we ran out because we could not pack enough values, or because we would
+        // overread.
+        ARROW_DCHECK((batch_size < kValuesUnpacked) || (in_end - in) < kBytesRead);
       }
-      batch_size -= unpacker_iter_count * kValuesUnpacked;
 
       // Running the epilog for the remaining values that don't fit in a kernel
-      ARROW_DCHECK_LT(batch_size, kValuesUnpacked);
       ARROW_DCHECK_GE(batch_size, 0);
-      ARROW_COMPILER_ASSUME(batch_size < kValuesUnpacked);
       ARROW_COMPILER_ASSUME(batch_size >= 0);
       unpack_exact<kPackedBitWidth, false>(in, out, batch_size, /* bit_offset= */ 0);
     }
@@ -209,276 +232,401 @@ void unpack_width(const uint8_t* in, UnpackedUInt* out, int batch_size, int bit_
 }
 
 template <template <typename, int> typename Unpacker, typename UnpackedUint>
-static void unpack_jump(const uint8_t* in, UnpackedUint* out, int batch_size,
-                        int num_bits, int bit_offset) {
+static void unpack_jump(const uint8_t* in, UnpackedUint* out, const UnpackOptions& opt) {
   if constexpr (std::is_same_v<UnpackedUint, bool>) {
-    switch (num_bits) {
+    switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
     }
   } else if constexpr (sizeof(UnpackedUint) == 1) {
-    switch (num_bits) {
+    switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
     }
   } else if constexpr (sizeof(UnpackedUint) == 2) {
-    switch (num_bits) {
+    switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
     }
   } else if constexpr (sizeof(UnpackedUint) == 4) {
-    switch (num_bits) {
+    switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
     }
   } else if constexpr (sizeof(UnpackedUint) == 8) {
-    switch (num_bits) {
+    switch (opt.bit_width) {
       case 0:
-        return unpack_width<0, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<0, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 1:
-        return unpack_width<1, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<1, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 2:
-        return unpack_width<2, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<2, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 3:
-        return unpack_width<3, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<3, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 4:
-        return unpack_width<4, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<4, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 5:
-        return unpack_width<5, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<5, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 6:
-        return unpack_width<6, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<6, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 7:
-        return unpack_width<7, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<7, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 8:
-        return unpack_width<8, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<8, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 9:
-        return unpack_width<9, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<9, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                         opt.max_read_bytes);
       case 10:
-        return unpack_width<10, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<10, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 11:
-        return unpack_width<11, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<11, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 12:
-        return unpack_width<12, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<12, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 13:
-        return unpack_width<13, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<13, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 14:
-        return unpack_width<14, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<14, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 15:
-        return unpack_width<15, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<15, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 16:
-        return unpack_width<16, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<16, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 17:
-        return unpack_width<17, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<17, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 18:
-        return unpack_width<18, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<18, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 19:
-        return unpack_width<19, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<19, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 20:
-        return unpack_width<20, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<20, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 21:
-        return unpack_width<21, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<21, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 22:
-        return unpack_width<22, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<22, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 23:
-        return unpack_width<23, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<23, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 24:
-        return unpack_width<24, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<24, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 25:
-        return unpack_width<25, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<25, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 26:
-        return unpack_width<26, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<26, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 27:
-        return unpack_width<27, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<27, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 28:
-        return unpack_width<28, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<28, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 29:
-        return unpack_width<29, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<29, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 30:
-        return unpack_width<30, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<30, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 31:
-        return unpack_width<31, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<31, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 32:
-        return unpack_width<32, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<32, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 33:
-        return unpack_width<33, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<33, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 34:
-        return unpack_width<34, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<34, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 35:
-        return unpack_width<35, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<35, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 36:
-        return unpack_width<36, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<36, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 37:
-        return unpack_width<37, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<37, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 38:
-        return unpack_width<38, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<38, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 39:
-        return unpack_width<39, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<39, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 40:
-        return unpack_width<40, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<40, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 41:
-        return unpack_width<41, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<41, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 42:
-        return unpack_width<42, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<42, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 43:
-        return unpack_width<43, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<43, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 44:
-        return unpack_width<44, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<44, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 45:
-        return unpack_width<45, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<45, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 46:
-        return unpack_width<46, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<46, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 47:
-        return unpack_width<47, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<47, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 48:
-        return unpack_width<48, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<48, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 49:
-        return unpack_width<49, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<49, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 50:
-        return unpack_width<50, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<50, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 51:
-        return unpack_width<51, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<51, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 52:
-        return unpack_width<52, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<52, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 53:
-        return unpack_width<53, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<53, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 54:
-        return unpack_width<54, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<54, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 55:
-        return unpack_width<55, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<55, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 56:
-        return unpack_width<56, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<56, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 57:
-        return unpack_width<57, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<57, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 58:
-        return unpack_width<58, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<58, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 59:
-        return unpack_width<59, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<59, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 60:
-        return unpack_width<60, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<60, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 61:
-        return unpack_width<61, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<61, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 62:
-        return unpack_width<62, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<62, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 63:
-        return unpack_width<63, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<63, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
       case 64:
-        return unpack_width<64, Unpacker>(in, out, batch_size, bit_offset);
+        return unpack_width<64, Unpacker>(in, out, opt.batch_size, opt.bit_offset,
+                                          opt.max_read_bytes);
     }
   }
-  ARROW_DCHECK(false) << "Unsupported num_bits " << num_bits;
+  ARROW_DCHECK(false) << "Unsupported num_bits " << opt.bit_width;
 }
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_internal.h b/cpp/src/arrow/util/bpacking_internal.h
index dd2a7e3ce93..329a1ae959b 100644
--- a/cpp/src/arrow/util/bpacking_internal.h
+++ b/cpp/src/arrow/util/bpacking_internal.h
@@ -23,28 +23,29 @@
 
 namespace arrow::internal {
 
+struct UnpackOptions {
+  int batch_size;
+  int bit_width;
+  int bit_offset = 0;
+  int max_read_bytes = -1;
+};
+
 template <typename Uint>
-ARROW_EXPORT void unpack(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                         int bit_offset = 0);
+ARROW_EXPORT void unpack(const uint8_t* in, Uint* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack<bool>(const uint8_t* in, bool* out,
-                                                        int batch_size, int num_bits,
-                                                        int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack<uint8_t>(const uint8_t* in,
-                                                           uint8_t* out, int batch_size,
-                                                           int num_bits, int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack<uint8_t>(  //
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack<uint16_t>(const uint8_t* in,
-                                                            uint16_t* out, int batch_size,
-                                                            int num_bits, int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack<uint16_t>(  //
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack<uint32_t>(const uint8_t* in,
-                                                            uint32_t* out, int batch_size,
-                                                            int num_bits, int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack<uint32_t>(  //
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack<uint64_t>(const uint8_t* in,
-                                                            uint64_t* out, int batch_size,
-                                                            int num_bits, int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack<uint64_t>(  //
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_scalar.cc b/cpp/src/arrow/util/bpacking_scalar.cc
index b4265379335..4209117617d 100644
--- a/cpp/src/arrow/util/bpacking_scalar.cc
+++ b/cpp/src/arrow/util/bpacking_scalar.cc
@@ -16,21 +16,21 @@
 // under the License.
 
 #include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/bpacking_scalar_generated_internal.h"
 #include "arrow/util/bpacking_scalar_internal.h"
 
 namespace arrow::internal {
 
 template <typename Uint>
-void unpack_scalar(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                   int bit_offset) {
-  return unpack_jump<ScalarUnpackerForWidth>(in, out, batch_size, num_bits, bit_offset);
+void unpack_scalar(const uint8_t* in, Uint* out, const UnpackOptions& opts) {
+  return unpack_jump<ScalarUnpackerForWidth>(in, out, opts);
 }
 
-template void unpack_scalar<bool>(const uint8_t*, bool*, int, int, int);
-template void unpack_scalar<uint8_t>(const uint8_t*, uint8_t*, int, int, int);
-template void unpack_scalar<uint16_t>(const uint8_t*, uint16_t*, int, int, int);
-template void unpack_scalar<uint32_t>(const uint8_t*, uint32_t*, int, int, int);
-template void unpack_scalar<uint64_t>(const uint8_t*, uint64_t*, int, int, int);
+template void unpack_scalar<bool>(const uint8_t*, bool*, const UnpackOptions&);
+template void unpack_scalar<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&);
+template void unpack_scalar<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
+template void unpack_scalar<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
+template void unpack_scalar<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_scalar_codegen.py b/cpp/src/arrow/util/bpacking_scalar_codegen.py
index 39b1190d921..91bf596df5c 100644
--- a/cpp/src/arrow/util/bpacking_scalar_codegen.py
+++ b/cpp/src/arrow/util/bpacking_scalar_codegen.py
@@ -114,6 +114,9 @@ def total_out_values(self, bit: int) -> int:
             self.total_in_values * bit + self.out_bit_width - 1
         ) // self.out_bit_width
 
+    def total_in_bytes(self, bit: int) -> int:
+        return (self.total_in_values * bit) // 8
+
     def total_out_bytes(self, bit: int) -> int:
         return (
             self.total_in_values * bit + self.out_byte_width - 1
@@ -186,6 +189,7 @@ def print_struct_k(self, bit: int) -> None:
         print(f"struct {self.struct_specialization(bit)} {{")
         print()
         print(f"  static constexpr int kValuesUnpacked = {self.total_in_values};")
+        print(f"  static constexpr int kBytesRead = {self.total_in_bytes(bit)};")
         print()
         self.print_unpack_k(bit)
         print("};")
@@ -199,6 +203,10 @@ def print_uint32_fallback_struct(self):
             "  static constexpr int kValuesUnpacked = "
             f"{self.struct_name}<uint32_t, kBitWidth>::kValuesUnpacked;"
         )
+        print(
+            "  static constexpr int kBytesRead = "
+            f"{self.struct_name}<uint32_t, kBitWidth>::kBytesRead;"
+        )
         print()
 
         print(
diff --git a/cpp/src/arrow/util/bpacking_scalar_generated_internal.h b/cpp/src/arrow/util/bpacking_scalar_generated_internal.h
index dc21fddd5d5..24256189a33 100644
--- a/cpp/src/arrow/util/bpacking_scalar_generated_internal.h
+++ b/cpp/src/arrow/util/bpacking_scalar_generated_internal.h
@@ -41,6 +41,7 @@ template<int kBitWidth>
 struct ScalarUnpackerForWidth<bool, kBitWidth> {
 
   static constexpr int kValuesUnpacked = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, bool* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -56,6 +57,7 @@ template<int kBitWidth>
 struct ScalarUnpackerForWidth<uint8_t, kBitWidth> {
 
   static constexpr int kValuesUnpacked = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, uint8_t* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -71,6 +73,7 @@ template<int kBitWidth>
 struct ScalarUnpackerForWidth<uint16_t, kBitWidth> {
 
   static constexpr int kValuesUnpacked = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = ScalarUnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, uint16_t* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -86,6 +89,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 1> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 4;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 1) - uint32_t{1});
@@ -132,6 +136,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 2> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 8;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 2) - uint32_t{1});
@@ -179,6 +184,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 3> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 12;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 3) - uint32_t{1});
@@ -227,6 +233,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 4> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 16;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 4) - uint32_t{1});
@@ -276,6 +283,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 5> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 20;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 5) - uint32_t{1});
@@ -326,6 +334,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 6> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 24;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 6) - uint32_t{1});
@@ -377,6 +386,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 7> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 28;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 7) - uint32_t{1});
@@ -429,6 +439,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 8> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 32;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 8) - uint32_t{1});
@@ -482,6 +493,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 9> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 36;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 9) - uint32_t{1});
@@ -536,6 +548,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 10> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 40;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 10) - uint32_t{1});
@@ -591,6 +604,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 11> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 44;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 11) - uint32_t{1});
@@ -647,6 +661,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 12> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 48;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 12) - uint32_t{1});
@@ -704,6 +719,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 13> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 52;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 13) - uint32_t{1});
@@ -762,6 +778,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 14> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 56;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 14) - uint32_t{1});
@@ -821,6 +838,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 15> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 60;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 15) - uint32_t{1});
@@ -881,6 +899,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 16> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 64;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 16) - uint32_t{1});
@@ -942,6 +961,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 17> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 68;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 17) - uint32_t{1});
@@ -1004,6 +1024,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 18> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 72;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 18) - uint32_t{1});
@@ -1067,6 +1088,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 19> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 76;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 19) - uint32_t{1});
@@ -1131,6 +1153,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 20> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 80;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 20) - uint32_t{1});
@@ -1196,6 +1219,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 21> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 84;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 21) - uint32_t{1});
@@ -1262,6 +1286,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 22> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 88;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 22) - uint32_t{1});
@@ -1329,6 +1354,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 23> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 92;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 23) - uint32_t{1});
@@ -1397,6 +1423,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 24> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 96;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 24) - uint32_t{1});
@@ -1466,6 +1493,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 25> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 100;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 25) - uint32_t{1});
@@ -1536,6 +1564,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 26> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 104;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 26) - uint32_t{1});
@@ -1607,6 +1636,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 27> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 108;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 27) - uint32_t{1});
@@ -1679,6 +1709,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 28> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 112;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 28) - uint32_t{1});
@@ -1752,6 +1783,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 29> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 116;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 29) - uint32_t{1});
@@ -1826,6 +1858,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 30> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 120;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 30) - uint32_t{1});
@@ -1901,6 +1934,7 @@ template<>
 struct ScalarUnpackerForWidth<uint32_t, 31> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 124;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t mask = ((uint32_t{1} << 31) - uint32_t{1});
@@ -1978,6 +2012,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 1> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 4;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 1) - uint64_t{1});
@@ -2024,6 +2059,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 2> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 8;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 2) - uint64_t{1});
@@ -2070,6 +2106,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 3> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 12;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 3) - uint64_t{1});
@@ -2117,6 +2154,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 4> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 16;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 4) - uint64_t{1});
@@ -2164,6 +2202,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 5> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 20;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 5) - uint64_t{1});
@@ -2212,6 +2251,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 6> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 24;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 6) - uint64_t{1});
@@ -2260,6 +2300,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 7> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 28;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 7) - uint64_t{1});
@@ -2309,6 +2350,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 8> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 32;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 8) - uint64_t{1});
@@ -2358,6 +2400,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 9> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 36;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 9) - uint64_t{1});
@@ -2408,6 +2451,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 10> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 40;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 10) - uint64_t{1});
@@ -2458,6 +2502,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 11> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 44;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 11) - uint64_t{1});
@@ -2509,6 +2554,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 12> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 48;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 12) - uint64_t{1});
@@ -2560,6 +2606,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 13> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 52;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 13) - uint64_t{1});
@@ -2612,6 +2659,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 14> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 56;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 14) - uint64_t{1});
@@ -2664,6 +2712,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 15> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 60;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 15) - uint64_t{1});
@@ -2717,6 +2766,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 16> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 64;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 16) - uint64_t{1});
@@ -2770,6 +2820,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 17> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 68;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 17) - uint64_t{1});
@@ -2824,6 +2875,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 18> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 72;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 18) - uint64_t{1});
@@ -2878,6 +2930,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 19> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 76;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 19) - uint64_t{1});
@@ -2933,6 +2986,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 20> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 80;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 20) - uint64_t{1});
@@ -2988,6 +3042,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 21> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 84;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 21) - uint64_t{1});
@@ -3044,6 +3099,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 22> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 88;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 22) - uint64_t{1});
@@ -3100,6 +3156,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 23> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 92;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 23) - uint64_t{1});
@@ -3157,6 +3214,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 24> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 96;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 24) - uint64_t{1});
@@ -3214,6 +3272,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 25> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 100;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 25) - uint64_t{1});
@@ -3272,6 +3331,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 26> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 104;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 26) - uint64_t{1});
@@ -3330,6 +3390,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 27> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 108;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 27) - uint64_t{1});
@@ -3389,6 +3450,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 28> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 112;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 28) - uint64_t{1});
@@ -3448,6 +3510,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 29> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 116;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 29) - uint64_t{1});
@@ -3508,6 +3571,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 30> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 120;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 30) - uint64_t{1});
@@ -3568,6 +3632,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 31> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 124;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 31) - uint64_t{1});
@@ -3629,6 +3694,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 32> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 128;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 32) - uint64_t{1});
@@ -3690,6 +3756,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 33> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 132;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 33) - uint64_t{1});
@@ -3752,6 +3819,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 34> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 136;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 34) - uint64_t{1});
@@ -3814,6 +3882,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 35> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 140;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 35) - uint64_t{1});
@@ -3877,6 +3946,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 36> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 144;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 36) - uint64_t{1});
@@ -3940,6 +4010,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 37> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 148;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 37) - uint64_t{1});
@@ -4004,6 +4075,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 38> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 152;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 38) - uint64_t{1});
@@ -4068,6 +4140,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 39> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 156;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 39) - uint64_t{1});
@@ -4133,6 +4206,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 40> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 160;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 40) - uint64_t{1});
@@ -4198,6 +4272,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 41> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 164;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 41) - uint64_t{1});
@@ -4264,6 +4339,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 42> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 168;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 42) - uint64_t{1});
@@ -4330,6 +4406,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 43> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 172;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 43) - uint64_t{1});
@@ -4397,6 +4474,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 44> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 176;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 44) - uint64_t{1});
@@ -4464,6 +4542,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 45> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 180;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 45) - uint64_t{1});
@@ -4532,6 +4611,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 46> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 184;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 46) - uint64_t{1});
@@ -4600,6 +4680,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 47> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 188;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 47) - uint64_t{1});
@@ -4669,6 +4750,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 48> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 192;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 48) - uint64_t{1});
@@ -4738,6 +4820,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 49> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 196;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 49) - uint64_t{1});
@@ -4808,6 +4891,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 50> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 200;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 50) - uint64_t{1});
@@ -4878,6 +4962,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 51> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 204;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 51) - uint64_t{1});
@@ -4949,6 +5034,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 52> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 208;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 52) - uint64_t{1});
@@ -5020,6 +5106,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 53> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 212;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 53) - uint64_t{1});
@@ -5092,6 +5179,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 54> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 216;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 54) - uint64_t{1});
@@ -5164,6 +5252,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 55> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 220;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 55) - uint64_t{1});
@@ -5237,6 +5326,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 56> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 224;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 56) - uint64_t{1});
@@ -5310,6 +5400,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 57> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 228;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 57) - uint64_t{1});
@@ -5384,6 +5475,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 58> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 232;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 58) - uint64_t{1});
@@ -5458,6 +5550,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 59> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 236;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 59) - uint64_t{1});
@@ -5533,6 +5626,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 60> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 240;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 60) - uint64_t{1});
@@ -5608,6 +5702,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 61> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 244;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 61) - uint64_t{1});
@@ -5684,6 +5779,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 62> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 248;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 62) - uint64_t{1});
@@ -5760,6 +5856,7 @@ template<>
 struct ScalarUnpackerForWidth<uint64_t, 63> {
 
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 252;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t mask = ((uint64_t{1} << 63) - uint64_t{1});
diff --git a/cpp/src/arrow/util/bpacking_scalar_internal.h b/cpp/src/arrow/util/bpacking_scalar_internal.h
index 7885f68e7b3..68186a519fd 100644
--- a/cpp/src/arrow/util/bpacking_scalar_internal.h
+++ b/cpp/src/arrow/util/bpacking_scalar_internal.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/visibility.h"
 
 #include <cstdint>
@@ -24,24 +25,21 @@
 namespace arrow::internal {
 
 template <typename Uint>
-ARROW_EXPORT void unpack_scalar(const uint8_t* in, Uint* out, int batch_size,
-                                int num_bits, int bit_offset);
+ARROW_EXPORT void unpack_scalar(const uint8_t* in, Uint* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<bool>(const uint8_t* in,
-                                                               bool* out, int batch_size,
-                                                               int num_bits,
-                                                               int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint8_t>(
-    const uint8_t* in, uint8_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint16_t>(
-    const uint8_t* in, uint16_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint32_t>(
-    const uint8_t* in, uint32_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_scalar<uint64_t>(
-    const uint8_t* in, uint64_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_simd128_generated_internal.h b/cpp/src/arrow/util/bpacking_simd128_generated_internal.h
deleted file mode 100644
index c171da11c6f..00000000000
--- a/cpp/src/arrow/util/bpacking_simd128_generated_internal.h
+++ /dev/null
@@ -1,24821 +0,0 @@
-// 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.
-
-// WARNING: this file is generated, DO NOT EDIT.
-// Usage:
-//   python cpp/src/arrow/util/bpacking_simd_codegen.py 128
-
-#pragma once
-
-#include <cstdint>
-#include <cstring>
-
-#include <xsimd/xsimd.hpp>
-
-#include "arrow/util/ubsan.h"
-
-namespace arrow::internal {
-namespace {
-
-using ::arrow::util::SafeLoadAs;
-
-template<typename Uint, int BitWidth>
-struct Simd128UnpackerForWidth;
-
-template<int kBitWidth>
-struct Simd128UnpackerForWidth<bool, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd128UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, bool* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd128UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<bool>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<int kBitWidth>
-struct Simd128UnpackerForWidth<uint8_t, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd128UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, uint8_t* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd128UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<uint8_t>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<int kBitWidth>
-struct Simd128UnpackerForWidth<uint16_t, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd128UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, uint16_t* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd128UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<uint16_t>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 1> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 1-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 1, 2, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 4, 5, 6, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 8, 9, 10, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 12, 13, 14, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 16, 17, 18, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 20, 21, 22, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 24, 25, 26, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 28, 29, 30, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 1 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 2> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 2-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 2 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 3> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 3-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 3, 6, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 12, 15, 18, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 24, 27, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 4, 7, 10, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 16, 19, 22, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 28, 0, 2, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 8, 11, 14, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 20, 23, 26, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 3 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 4> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xf;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 4-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 4 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 5> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 5-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 5, 10, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 20, 25, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 8, 13, 18, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 1, 6, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 3) << 1,
-    };
-    shifts = simd_batch{ 16, 21, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 4, 9, 14, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 4) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 24, 0, 2, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 12, 17, 22, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 5 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 6> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 6-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 24, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 16, 22, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 24, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 16, 22, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 6 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 7> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 7-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 7, 14, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 3, 10, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 24, 0, 6, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 3) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 20, 0, 2, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 16, 23, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 12, 19, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-    };
-    shifts = simd_batch{ 8, 15, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 4, 11, 18, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 7 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 8> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 8-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 8 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 9> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 9-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 1) << 5,
-    };
-    shifts = simd_batch{ 0, 9, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-    };
-    shifts = simd_batch{ 4, 13, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 8, 17, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 12, 21, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 5) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 16, 0, 2, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 20, 0, 6, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 1, 10, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 5, 14, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 9 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 10> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 10-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-    };
-    shifts = simd_batch{ 0, 10, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 8, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 16, 0, 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 6) << 2,
-    };
-    shifts = simd_batch{ 0, 10, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 8, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 8) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 16, 0, 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 10 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 11> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 11-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 1) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 11, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 2) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 12, 0, 2, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 3) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 4) << 7,
-    };
-    shifts = simd_batch{ 0, 3, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 4, 15, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 6) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 16, 0, 6, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 8) << 3,
-    };
-    shifts = simd_batch{ 0, 7, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 8, 19, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 10) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 20, 0, 10, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 11 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 12> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 12-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 1) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 11) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 12 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 13> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 13-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 1) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 13, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 2) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 3) << 5,
-    };
-    shifts = simd_batch{ 0, 1, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 4) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 8, 0, 2, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 0, 9, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 7) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 8) << 9,
-    };
-    shifts = simd_batch{ 16, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 4, 17, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 11) << 1,
-    };
-    shifts = simd_batch{ 0, 5, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 12) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 12, 0, 6, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 13 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 14> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 14-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 2) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-    };
-    shifts = simd_batch{ 16, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 8, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 11) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-    };
-    shifts = simd_batch{ 16, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 13) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 8, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 14 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 15> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 15-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 15, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 11, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 7, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 3, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 8) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 9) << 3,
-    };
-    shifts = simd_batch{ 16, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 10) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 11) << 7,
-    };
-    shifts = simd_batch{ 12, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 12) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 13) << 11,
-    };
-    shifts = simd_batch{ 8, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 14) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 4, 0, 2, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 15 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 16> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 16-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 16 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 17> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 17-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 1) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 2) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 3) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 4) << 9,
-    };
-    shifts = simd_batch{ 4, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 5) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 6) << 5,
-    };
-    shifts = simd_batch{ 8, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 7) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 8) << 1,
-    };
-    shifts = simd_batch{ 12, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 9) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 10) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 0, 1, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 11) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 12) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 0, 5, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 13) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 14) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 9, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 15) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 16) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-    };
-    shifts = simd_batch{ 0, 13, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 17 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 18> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 18-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 1) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 2) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-    };
-    shifts = simd_batch{ 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 5) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 10) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 11) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 13) << 2,
-    };
-    shifts = simd_batch{ 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 15) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-    };
-    shifts = simd_batch{ 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 18 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 19> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 19-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 1) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 2) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 3) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 4) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 12, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 5) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 6) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 7) << 15,
-    };
-    shifts = simd_batch{ 0, 11, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 8) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 9) << 3,
-    };
-    shifts = simd_batch{ 4, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 10) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 11) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 3, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 12) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 13) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 14) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 15) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 16) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-    };
-    shifts = simd_batch{ 8, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 17) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 18) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-    };
-    shifts = simd_batch{ 0, 7, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 19 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 20> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 20-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 1) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 3) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 11) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 12) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 13) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 14) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 16) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 18) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 20 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 21> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 21-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 1) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 5) << 13,
-    };
-    shifts = simd_batch{ 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 8, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 9) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 10) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 13) << 17,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 14) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 15) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-    };
-    shifts = simd_batch{ 4, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 17) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 18) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 19) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 20) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-    };
-    shifts = simd_batch{ 0, 1, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 21 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 22> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 22-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 1) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 2) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 3) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 4) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 6) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 8) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 8, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 12) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 13) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 14) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 15) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 16) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 17) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 18) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 19) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 20) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 21) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-    };
-    shifts = simd_batch{ 8, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 22 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 23> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 23-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 1) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 2) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 3) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 4) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 5) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 6) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 7) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 8) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 9) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 10) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 11) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 12) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 13) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 14) << 11,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 15) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 16) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 17) << 15,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 18) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 19) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 20) << 19,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 21) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 22) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 22),
-    };
-    shifts = simd_batch{ 4, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 23 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 24> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 24-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 1) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 2) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 5) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 13) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 17) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 20) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 22) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 23) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 23),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 24 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 25> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 25-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 1) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 2) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 3) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 4) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 6) << 17,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 7) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 8) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 9) << 13,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 10) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 11) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 12) << 9,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 13) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 14) << 23,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 15) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 16) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 17) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 18) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 20) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 21) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 22) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 23) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 24) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 24),
-    };
-    shifts = simd_batch{ 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 25 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 26> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 26-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 1) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 2) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 3) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 4) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 7) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 8) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 11) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 12) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 14) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 15) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 16) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 17) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 18) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 19) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 20) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 21) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 22) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 23) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 24) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 25) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 25),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 26 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 27> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 27-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 1) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 2) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 3) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 4) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 5) << 25,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 8) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 9) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 10) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 11) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 13) << 11,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 15) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 16) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 18) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 19) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 20) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 21) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 22) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 23) << 7,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 24) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 25) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 26) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 26),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 27 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 28> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 28-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 2) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 4) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 5) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 6) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 12) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 13) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 15) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 17) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 18) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 19) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 20) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 22) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 23) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 24) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 25) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 26) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 27) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 27),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 28 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 29> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 29-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 1) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 2) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 3) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 4) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 5) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 6) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 7) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 8) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 5 | SafeLoadAs<uint32_t>(in + 4 * 9) << 27,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 10) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 11) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 12) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 13) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 14) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 15) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 16) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 17) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 18) << 25,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 19) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 20) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 21) << 5,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 22) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 23) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 24) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 25) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 26) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 27) << 23,
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 28) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 28),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 29 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 30> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 30-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 9) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 10) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 11) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 12) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 13) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 14) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 16) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 18) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 20) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 21) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 22) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 23) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 24) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 25) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 26) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 27) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 28) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 28) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 29) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 29),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 30 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint32_t, 31> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 4>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 31-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 1) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 2) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 3) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 4) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 5) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 6) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 7) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 8) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 9) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 10) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 11) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 12) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 13) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 14) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 15) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 16) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 17) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 18) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 19) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 20) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 21) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 22) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 23) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 24) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 25) << 25,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 26) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 5 | SafeLoadAs<uint32_t>(in + 4 * 27) << 27,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 28) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 28) >> 3 | SafeLoadAs<uint32_t>(in + 4 * 29) << 29,
-      SafeLoadAs<uint32_t>(in + 4 * 29) >> 2 | SafeLoadAs<uint32_t>(in + 4 * 30) << 30,
-      SafeLoadAs<uint32_t>(in + 4 * 30),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 31 * 4;
-    return in;
-  }
-};
-
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 1> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 1-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 2, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 4, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 6, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 8, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 10, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 14, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 18, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 22, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 26, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 30, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 34, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 38, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 42, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 44, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 46, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 50, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 52, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 54, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 56, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 58, 59 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 60, 61 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 1-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 62, 63 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 1 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 2> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 2-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 8, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 44, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 52, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 56, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 60, 62 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 24, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 36, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 40, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 52, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 56, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 2-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 60, 62 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 2 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 3> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 3-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 6, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 18, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 30, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 42, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 54, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 60, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 2, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 14, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 26, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 38, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 50, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 56, 59 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 10, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 22, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 28, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 34, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 46, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 52, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 3-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 58, 61 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 3 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 4> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xf;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 4-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 48, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 16, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 4-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 4 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 5> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 5-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 10, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 30, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 50, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 6, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 26, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 36, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 46, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 2) << 3,
-    };
-    shifts = simd_batch{ 56, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 2, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 22, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 42, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 52, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 18, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 28, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 38, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 58, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 14, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 34, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 44, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 5-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 54, 59 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 5 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 6> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 6-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 56, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 28, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 52, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 36, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 44, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 5) << 2,
-    };
-    shifts = simd_batch{ 56, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 28, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 40, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 6-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 52, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 6 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 7> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 7-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 14, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 42, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 56, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 6, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 34, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 26, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 54, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 4, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 18, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 46, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 10, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 38, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 2, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 30, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 44, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 8, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 22, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 36, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 7-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 50, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 7 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 8> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 8-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 8-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 8 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 9> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 9-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 18, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 54, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 26, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 34, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 6, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 42, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 14, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 4, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 22, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 40, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 30, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 2, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 20, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 38, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 10, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 9-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 46, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 9 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 10> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 10-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 36, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-    };
-    shifts = simd_batch{ 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 28, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 44, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 20, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 40, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 36, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-    };
-    shifts = simd_batch{ 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 24, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 10-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 44, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 10 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 11> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 11-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 22, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 1) << 9,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 2, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 24, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 2) << 7,
-    };
-    shifts = simd_batch{ 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 26, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 3) << 5,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 6, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 28, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 4) << 3,
-    };
-    shifts = simd_batch{ 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 30, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 5) << 1,
-    };
-    shifts = simd_batch{ 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 10, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 34, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 14, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 36, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 38, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 18, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 40, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 20, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 11-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 42, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 11 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 12> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 12-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 7) << 4,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 10) << 4,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 32, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 12-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 12 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 13> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 13-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 26, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 14, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 2) << 11,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 2, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 28, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 16, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 4) << 9,
-    };
-    shifts = simd_batch{ 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 30, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 18, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 6) << 7,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 6, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 20, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 8) << 5,
-    };
-    shifts = simd_batch{ 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 34, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 22, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 10) << 3,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 10, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 36, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 24, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 12) << 1,
-    };
-    shifts = simd_batch{ 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 12, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 13-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 38, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 13 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 14> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 14-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 8, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 36, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 28, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 20, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 9) << 2,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 12, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 32, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 24, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 16, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 13) << 6,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 14-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 36, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 14 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 15> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 15-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 30, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 26, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 22, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 18, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 48, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 14, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 10, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 6) << 9,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 6, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 7) << 13,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 2, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 24, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 20, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 12, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 14) << 11,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 4, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 15-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 34, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 15 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 16> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 16-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 16-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 16 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 17> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 17-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 1) << 13,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 4, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 2) << 9,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 8, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 3) << 5,
-    };
-    shifts = simd_batch{ 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 12, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 16, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 20, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 24, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 28, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 2, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 10) << 11,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 6, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 11) << 7,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 10, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 14, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 18, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 22, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 26, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 17-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 30, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 17 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 18> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 18-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 4, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 20, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 8, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 24, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 4, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 15) << 6,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 12, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 20, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 18-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 28, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 18 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 19> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 19-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 1) << 7,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 12, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 24, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 4) << 9,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 10, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 5) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 22, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 7) << 11,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 8, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 20, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 6, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 11) << 1,
-    };
-    shifts = simd_batch{ 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 18, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 13) << 15,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 4, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 14) << 3,
-    };
-    shifts = simd_batch{ 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 16, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 16) << 17,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 2, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 17) << 5,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 14, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 19-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 26, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 19 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 20> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 20-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 13) << 12,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 16, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 20-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 20 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 21> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 21-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 18, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 14, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 12, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 10, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 6, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 4, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 2, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 21-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 22, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 21 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 22> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 22-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 1) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 2) << 18,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 3) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 4) << 14,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 20, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 13) << 18,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 4, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 15) << 14,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 8, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 17) << 10,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 12, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 19) << 6,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 16, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 21) << 2,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 22-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 20, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 22 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 23> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 23-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 1) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 2) << 13,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 10, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 3) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 4) << 3,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 5) << 21,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 2, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 6) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 7) << 11,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 12, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 9) << 1,
-    };
-    shifts = simd_batch{ 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 10) << 19,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 4, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 12) << 9,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 14, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 15) << 17,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 6, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 17) << 7,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 16, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 20) << 15,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 8, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 22) << 5,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 23-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 18, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 23 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 24> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 24-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 1) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 14) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 20) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 23) << 8,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 24-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 24 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 25> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 25-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 1) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 2) << 3,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 3) << 17,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 6) << 9,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 7) << 23,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 2, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 9) << 1,
-    };
-    shifts = simd_batch{ 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 10) << 15,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 10, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 14) << 21,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 4, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 17) << 13,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 12, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 20) << 5,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 21) << 19,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 6, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 24) << 11,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 25-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 14, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 25 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 26> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 26-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 2) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 4) << 22,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 12, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 16) << 10,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 17) << 22,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 4, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 20) << 6,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 8, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 24) << 2,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 25) << 14,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 26-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 12, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 26 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 27> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 27-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 4) << 13,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 5) << 23,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 4, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 8) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 10) << 19,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 8, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 14) << 5,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 16) << 25,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 2, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 19) << 1,
-    };
-    shifts = simd_batch{ 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 20) << 11,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 6, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 23) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 25) << 7,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 26) << 17,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 27-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 10, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 27 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 28> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 28-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 2) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 18) << 4,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 19) << 12,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 26) << 12,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 27) << 20,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 28-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 28 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 29> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 29-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 1) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 2) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 3) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 4) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 5) << 1,
-    };
-    shifts = simd_batch{ 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 6) << 7,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 7) << 13,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 8) << 19,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 9) << 25,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 4, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 15) << 3,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 16) << 9,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 17) << 15,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 18) << 21,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 19) << 27,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 2, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 25) << 5,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 26) << 11,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 27) << 17,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 28) << 23,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 29-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 6, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 29 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 30> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 30-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 4, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 25) << 10,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 28) << 22,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 29) << 26,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 30-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 4, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 30 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 31> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 31-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 1) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 2) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 3) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 4) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 5) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 6) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 7) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 8) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 9) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 10) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 11) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 12) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 13) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 14) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 15) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 16) << 1,
-    };
-    shifts = simd_batch{ 32, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 17) << 3,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 18) << 5,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 19) << 7,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 20) << 9,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 21) << 11,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 22) << 13,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 23) << 15,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 24) << 17,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 25) << 19,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 26) << 21,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 27) << 23,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 28) << 25,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 29) << 27,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 30) << 29,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 31-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 2, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 31 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 32> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 32-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 32-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 32 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 33> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 33-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 1) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 2) << 29,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 3) << 27,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 4) << 25,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 5) << 23,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 6) << 21,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 7) << 19,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 12) << 9,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 14) << 5,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 15) << 3,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 16) << 1,
-    };
-    shifts = simd_batch{ 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 23) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 24) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 28) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 30) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 33-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 32) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 33 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 34> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 34-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 1) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 2) << 26,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 3) << 22,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 4) << 18,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 9) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 11) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 19) << 26,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 20) << 22,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 22) << 14,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 23) << 10,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 25) << 2,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 27) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 28) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 30) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 31) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 34-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 33) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 34 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 35> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 35-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 1) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 2) << 23,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 3) << 17,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 4) << 11,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 6) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 8) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 12) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 13) << 27,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 14) << 21,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 16) << 9,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 17) << 3,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 19) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 21) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 24) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 26) << 19,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 27) << 13,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 28) << 7,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 29) << 1,
-    };
-    shifts = simd_batch{ 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 32) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 35-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 34) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 35 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 36> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 36-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 1) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 5) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 21) << 12,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 26) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 30) << 12,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 33) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 36-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 35) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 36 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 37> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 37-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 1) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 2) << 17,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 3) << 7,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 4) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 5) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 6) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 7) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 8) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 9) << 21,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 10) << 11,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 11) << 1,
-    };
-    shifts = simd_batch{ 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 12) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 13) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 14) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 15) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 16) << 25,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 17) << 15,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 18) << 5,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 19) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 20) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 21) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 22) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 23) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 24) << 19,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 25) << 9,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 26) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 27) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 28) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 29) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 30) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 31) << 23,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 32) << 13,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 33) << 3,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 34) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 35) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 37-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 36) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-    };
-    shifts = simd_batch{ 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 37 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 38> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 38-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 1) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 4) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 5) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 7) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 10) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 16) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 21) << 14,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 22) << 2,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 23) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 24) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 26) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 28) << 6,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 30) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 31) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 32) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 33) << 22,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 34) << 10,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 35) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 38-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 37) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-    };
-    shifts = simd_batch{ 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 38 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 39> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 39-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 1) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 2) << 11,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 3) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 4) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 6) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 7) << 19,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 8) << 5,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 9) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 12) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 14) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 16) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 17) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 18) << 21,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 19) << 7,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 23) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 24) << 15,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 25) << 1,
-    };
-    shifts = simd_batch{ 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 28) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 29) << 23,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 30) << 9,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 31) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 32) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 33) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 34) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 35) << 17,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 36) << 3,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 39-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 38) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 39 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 40> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 40-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 1) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 3) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 11) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 13) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 24) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 26) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 27) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 29) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 33) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 37) << 8,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 40-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 39) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 40 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 41> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 41-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 1) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 2) << 5,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 3) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 4) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 5) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 6) << 15,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 7) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 8) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 9) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 10) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 11) << 7,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 12) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 13) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 14) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 15) << 17,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 16) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 17) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 18) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 19) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 20) << 9,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 21) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 22) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 23) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 24) << 19,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 25) << 1,
-    };
-    shifts = simd_batch{ 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 26) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 27) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 28) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 29) << 11,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 30) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 31) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 32) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 33) << 21,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 34) << 3,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 35) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 36) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 37) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 38) << 13,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 39) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 41-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 40) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-    };
-    shifts = simd_batch{ 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 41 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 42> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 42-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 1) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 5) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 9) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 15) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 17) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 27) << 6,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 31) << 10,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 35) << 14,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 39) << 18,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 42-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 41) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 42 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 43> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 43-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 1) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 2) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 3) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 4) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 5) << 19,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 6) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 7) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 8) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 9) << 17,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 10) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 11) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 12) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 13) << 15,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 14) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 15) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 16) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 17) << 13,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 18) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 19) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 20) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 21) << 11,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 22) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 23) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 24) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 25) << 9,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 26) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 27) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 28) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 29) << 7,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 30) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 31) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 32) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 33) << 5,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 34) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 35) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 36) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 37) << 3,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 38) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 39) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 40) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 41) << 1,
-    };
-    shifts = simd_batch{ 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 43-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 42) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-    };
-    shifts = simd_batch{ 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 43 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 44> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 44-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 1) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 2) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 3) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 4) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 6) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 8) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 13) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 15) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 23) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 24) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 26) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 30) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 32) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 34) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 36) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 37) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 38) << 12,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 39) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 40) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 41) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 42) << 4,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 44-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 43) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-    };
-    shifts = simd_batch{ 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 44 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 45> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 45-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 1) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 2) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 4) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 7) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 11) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 14) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 16) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 18) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 19) << 1,
-    };
-    shifts = simd_batch{ 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 21) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 22) << 13,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 28) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 29) << 11,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 32) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 33) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 36) << 9,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 38) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 39) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 41) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 42) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 43) << 7,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 45-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 44) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 45 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 46> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 46-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 1) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 2) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 3) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 4) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 5) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 6) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 7) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 9) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 10) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 12) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 15) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 17) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 20) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 24) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 25) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 26) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 27) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 28) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 29) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 30) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 31) << 6,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 32) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 33) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 34) << 14,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 35) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 36) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 37) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 38) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 39) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 40) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 41) << 2,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 42) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 43) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 44) << 10,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 46-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 45) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-    };
-    shifts = simd_batch{ 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 46 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 47> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 47-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 1) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 2) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 3) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 4) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 5) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 6) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 7) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 8) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 9) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 10) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 11) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 12) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 13) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 14) << 3,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 15) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 16) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 17) << 7,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 18) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 19) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 20) << 11,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 21) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 22) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 23) << 15,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 24) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 25) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 26) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 27) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 28) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 29) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 30) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 31) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 32) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 33) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 34) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 35) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 36) << 1,
-    };
-    shifts = simd_batch{ 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 37) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 38) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 39) << 5,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 40) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 41) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 42) << 9,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 43) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 44) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 45) << 13,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 47-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 46) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 46),
-    };
-    shifts = simd_batch{ 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 47 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 48> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 48-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 1) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 2) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 5) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 28) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 31) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 35) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 40) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 41) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 43) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 44) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 46) << 16,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 48-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 47) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 48 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 49> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 49-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 1) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 2) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 3) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 4) << 11,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 5) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 6) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 8) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 9) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 10) << 3,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 11) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 12) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 13) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 15) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 16) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 17) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 18) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 20) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 22) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 24) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 25) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 26) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 27) << 13,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 29) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 30) << 9,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 32) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 33) << 5,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 34) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 36) << 1,
-    };
-    shifts = simd_batch{ 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 38) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 39) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 40) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 41) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 43) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 44) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 45) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 46) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 47) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 49-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 48) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 49 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 50> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 50-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 1) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 2) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 3) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 6) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 7) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 9) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 10) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 13) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 14) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 17) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 20) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 21) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 24) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 27) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 28) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 29) << 6,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 30) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 31) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 32) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 34) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 36) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 37) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 39) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 40) << 10,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 41) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 42) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 43) << 2,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 44) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 45) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 46) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 46),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 47) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 48) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 50-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 49) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 49),
-    };
-    shifts = simd_batch{ 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 50 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 51> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 51-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 1) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 2) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 3) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 6) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 7) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 11) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 14) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 15) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 19) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 20) << 5,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 22) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 23) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 25) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 27) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 28) << 7,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 30) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 31) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 33) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 35) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 36) << 9,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 37) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 38) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 39) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 40) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 41) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 42) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 43) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 44) << 11,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 45) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 46) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 47) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 48) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 49) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 51-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 50) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 50),
-    };
-    shifts = simd_batch{ 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 51 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 52> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 52-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 2) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 3) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 4) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 7) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 8) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 11) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 12) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 16) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 17) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 21) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 25) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 28) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 29) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 30) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 31) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 32) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 33) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 34) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 35) << 4,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 36) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 38) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 40) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 41) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 42) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 43) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 44) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 45) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 46) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 47) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 48) << 4,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 49) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 50) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 52-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 51) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 51),
-    };
-    shifts = simd_batch{ 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 52 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 53> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 53-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 1) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 2) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 3) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 4) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 5) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 6) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 7) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 8) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 9) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 10) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 11) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 12) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 13) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 14) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 15) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 16) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 17) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 18) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 19) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 20) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 21) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 22) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 23) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 24) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 25) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 26) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 27) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 28) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 29) << 1,
-    };
-    shifts = simd_batch{ 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 30) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 31) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 32) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 33) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 34) << 3,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 35) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 36) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 37) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 38) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 39) << 5,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 40) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 41) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 42) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 43) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 44) << 7,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 45) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 46) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 47) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 48) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 49) << 9,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 50) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 51) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 53-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 52) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 52),
-    };
-    shifts = simd_batch{ 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 53 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 54> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 54-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 3) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 4) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 5) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 8) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 10) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 15) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 16) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 20) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 21) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 23) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 25) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 28) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 31) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 32) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 33) << 6,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 35) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 37) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 38) << 2,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 39) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 40) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 41) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 43) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 44) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 45) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 46) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 47) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 49) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 50) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 51) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 52) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 54-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 53) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 53),
-    };
-    shifts = simd_batch{ 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 54 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 55> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 55-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 1) << 9,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 2) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 3) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 4) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 5) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 6) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 9) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 10) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 11) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 12) << 53,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 15) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 16) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 17) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 18) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 19) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 20) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 22) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 23) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 24) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 25) << 5,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 27) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 29) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 30) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 32) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 33) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 34) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 36) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 37) << 3,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 38) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 39) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 40) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 41) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 42) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 43) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 44) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 45) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 46) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 47) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 48) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 49) << 1,
-    };
-    shifts = simd_batch{ 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 50) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 51) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 52) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 53) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 55-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 54) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 54),
-    };
-    shifts = simd_batch{ 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 55 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 56> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 56-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 2) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 4) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 5) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 6) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 12) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 13) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 20) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 25) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 26) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 27) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 30) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 33) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 34) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 36) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 38) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 39) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 41) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 43) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 44) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 45) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 46) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 47) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49),
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 50) << 8,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 51) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 52) << 24,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 53) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 54) << 40,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 56-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 55) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 55),
-    };
-    shifts = simd_batch{ 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 56 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 57> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 57-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 1) << 7,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 3) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 4) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 5) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 6) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 7) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 8) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 12) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 14) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 15) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 16) << 55,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 17) << 5,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 21) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 22) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 23) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 24) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 26) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 28) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 30) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 31) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 32) << 53,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 33) << 3,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 34) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 35) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 37) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 39) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 40) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 41) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 42) << 9,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 43) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 44) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 45) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 46) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 47) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 48) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 49) << 1,
-    };
-    shifts = simd_batch{ 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 50) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 51) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 52) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 53) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 54) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 55) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 57-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 56) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 56),
-    };
-    shifts = simd_batch{ 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 57 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 58> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 58-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 1) << 6,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 2) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 3) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 4) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 5) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 6) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 7) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 8) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 9) << 54,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 15) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 16) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 17) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 18) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 19) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 25) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 26) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 27) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 28) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 30) << 6,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 31) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 32) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 33) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 34) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 35) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 36) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 37) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 38) << 54,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 39) << 2,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 40) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 41) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 42) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 43) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 44) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 45) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 46) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 47) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 48) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 49) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 50) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 51) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 52) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 53) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 54) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 55) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 56) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 58-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 57) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 57),
-    };
-    shifts = simd_batch{ 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 58 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 59> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 59-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 1) << 5,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 2) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 3) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 4) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 5) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 6) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 7) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 8) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 9) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 10) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 11) << 55,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 12) << 1,
-    };
-    shifts = simd_batch{ 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 13) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 14) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 15) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 16) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 17) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 18) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 19) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 20) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 21) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 22) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 23) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 24) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 25) << 7,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 26) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 27) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 28) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 29) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 30) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 31) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 32) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 33) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 34) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 35) << 57,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 36) << 3,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 37) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 38) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 39) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 40) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 41) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 42) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 43) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 44) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 45) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 46) << 53,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 47) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 48) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 49) << 9,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 50) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 51) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 52) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 53) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 54) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 55) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 56) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 57) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 59-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 58) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 58),
-    };
-    shifts = simd_batch{ 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 59 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 60> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 60-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 10) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 11) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 12) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 13) << 52,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 14) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 24) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 25) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 27) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 28) << 52,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 29) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 35) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 39) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 41) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 42) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 43) << 52,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 44) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 46) << 4,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 47) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 48) << 12,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 49) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 50) << 20,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 51) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 52) << 28,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 53) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 54) << 36,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 55) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 56) << 44,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 57) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 58) << 52,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 60-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 59) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 59),
-    };
-    shifts = simd_batch{ 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 60 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 61> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 61-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 1) << 3,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 2) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 3) << 9,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 4) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 5) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 6) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 7) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 8) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 9) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 10) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 11) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 12) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 13) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 14) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 15) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 16) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 17) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 18) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 19) << 57,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 20) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 21) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 22) << 5,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 23) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 24) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 25) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 26) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 27) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 28) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 29) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 30) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 31) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 32) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 33) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 34) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 35) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 36) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 37) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 38) << 53,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 39) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 5 | SafeLoadAs<uint64_t>(in + 8 * 40) << 59,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 41) << 1,
-    };
-    shifts = simd_batch{ 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 42) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 43) << 7,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 44) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 45) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 46) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 47) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 48) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 49) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 50) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 51) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 52) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 53) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 54) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 55) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 56) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 57) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 58) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 59) << 55,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 61-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 60) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 60),
-    };
-    shifts = simd_batch{ 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 61 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 62> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 62-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 1) << 2,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 2) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 3) << 6,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 4) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 5) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 6) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 7) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 8) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 9) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 10) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 11) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 12) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 13) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 14) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 15) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 16) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 17) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 18) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 19) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 20) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 21) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 22) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 23) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 24) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 25) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 26) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 27) << 54,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 28) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 29) << 58,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 30) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 32) << 2,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 33) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 34) << 6,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 35) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 36) << 10,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 37) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 38) << 14,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 39) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 40) << 18,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 41) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 42) << 22,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 43) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 44) << 26,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 45) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 46) << 30,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 47) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 48) << 34,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 49) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 50) << 38,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 51) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 52) << 42,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 53) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 54) << 46,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 55) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 56) << 50,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 57) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 58) << 54,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 59) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 60) << 58,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 62-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 60) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 61) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 61),
-    };
-    shifts = simd_batch{ 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 62 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd128UnpackerForWidth<uint64_t, 63> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 2>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 63-bit bundles 0 to 1
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 2 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 4 to 5
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 6 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 8 to 9
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 10 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 12 to 13
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 14 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 16 to 17
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 18 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 20 to 21
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 22 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 23) << 23,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 24 to 25
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 26 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 27) << 27,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 28 to 29
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 29) << 29,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 30 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 31) << 31,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 32 to 33
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 33) << 33,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 34 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 36 to 37
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 37) << 37,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 38 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 39) << 39,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 40 to 41
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 41) << 41,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 42 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 43) << 43,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 44 to 45
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 44) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 45) << 45,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 46 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 46) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 47) << 47,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 48 to 49
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 49) << 49,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 50 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 50) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 51) << 51,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 52 to 53
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 52) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 53) << 53,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 54 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 54) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 55) << 55,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 56 to 57
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 56) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 57) << 57,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 58 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 58) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 5 | SafeLoadAs<uint64_t>(in + 8 * 59) << 59,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 60 to 61
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 60) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 60) >> 3 | SafeLoadAs<uint64_t>(in + 8 * 61) << 61,
-    };
-    shifts = simd_batch{ 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    // extract 63-bit bundles 62 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 61) >> 2 | SafeLoadAs<uint64_t>(in + 8 * 62) << 62,
-      SafeLoadAs<uint64_t>(in + 8 * 62),
-    };
-    shifts = simd_batch{ 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 2;
-
-    in += 63 * 8;
-    return in;
-  }
-};
-
-
-}  // namespace
-}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_simd256_generated_internal.h b/cpp/src/arrow/util/bpacking_simd256_generated_internal.h
deleted file mode 100644
index ef8c12c077c..00000000000
--- a/cpp/src/arrow/util/bpacking_simd256_generated_internal.h
+++ /dev/null
@@ -1,15765 +0,0 @@
-// 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.
-
-// WARNING: this file is generated, DO NOT EDIT.
-// Usage:
-//   python cpp/src/arrow/util/bpacking_simd_codegen.py 256
-
-#pragma once
-
-#include <cstdint>
-#include <cstring>
-
-#include <xsimd/xsimd.hpp>
-
-#include "arrow/util/ubsan.h"
-
-namespace arrow::internal {
-namespace {
-
-using ::arrow::util::SafeLoadAs;
-
-template<typename Uint, int BitWidth>
-struct Simd256UnpackerForWidth;
-
-template<int kBitWidth>
-struct Simd256UnpackerForWidth<bool, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd256UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, bool* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd256UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<bool>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<int kBitWidth>
-struct Simd256UnpackerForWidth<uint8_t, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd256UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, uint8_t* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd256UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<uint8_t>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<int kBitWidth>
-struct Simd256UnpackerForWidth<uint16_t, kBitWidth> {
-
-  static constexpr int kValuesUnpacked = Simd256UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
-
-  static const uint8_t* unpack(const uint8_t* in, uint16_t* out) {
-    uint32_t buffer[kValuesUnpacked] = {};
-    in = Simd256UnpackerForWidth<uint32_t, kBitWidth>::unpack(in, buffer);
-    for(int k = 0; k< kValuesUnpacked; ++k) {
-      out[k] = static_cast<uint16_t>(buffer[k]);
-    }
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 1> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 1-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 1, 2, 3, 4, 5, 6, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 1-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 8, 9, 10, 11, 12, 13, 14, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 1-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 16, 17, 18, 19, 20, 21, 22, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 1-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 24, 25, 26, 27, 28, 29, 30, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 1 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 2> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 2-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6, 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 2-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22, 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 2-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6, 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 2-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22, 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 2 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 3> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 3-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 3, 6, 9, 12, 15, 18, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 3-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 24, 27, 0, 1, 4, 7, 10, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 3-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 16, 19, 22, 25, 28, 0, 2, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 3-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 8, 11, 14, 17, 20, 23, 26, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 3 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 4> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xf;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 4-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12, 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 4-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12, 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 4-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12, 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 4-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12, 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 4 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 5> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 5-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 5, 10, 15, 20, 25, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 5-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 8, 13, 18, 23, 0, 1, 6, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 5-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 3) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 16, 21, 26, 0, 4, 9, 14, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 5-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 4) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 24, 0, 2, 7, 12, 17, 22, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 5 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 6> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 6-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18, 24, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 6-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 16, 22, 0, 2, 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 6-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18, 24, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 6-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 16, 22, 0, 2, 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 6 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 7> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 7-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 7, 14, 21, 0, 3, 10, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 7-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 3) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 24, 0, 6, 13, 20, 0, 2, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 7-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 16, 23, 0, 5, 12, 19, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 7-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 8, 15, 22, 0, 4, 11, 18, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 7 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 8> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 8-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24, 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 8-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24, 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 8-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24, 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 8-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24, 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 8 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 9> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 9-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 1) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-    };
-    shifts = simd_batch{ 0, 9, 18, 0, 4, 13, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 9-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 8, 17, 0, 3, 12, 21, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 9-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 5) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 16, 0, 2, 11, 20, 0, 6, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 9-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 1, 10, 19, 0, 5, 14, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 9 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 10> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 10-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 10, 20, 0, 8, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 10-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 16, 0, 4, 14, 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 10-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 6) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 10, 20, 0, 8, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 10-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 8) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 16, 0, 4, 14, 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 10 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 11> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 11-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 1) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 2) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 11, 0, 1, 12, 0, 2, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 11-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 3) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 4) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 3, 14, 0, 4, 15, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 11-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 6) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 8) << 3,
-    };
-    shifts = simd_batch{ 16, 0, 6, 17, 0, 7, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 11-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 10) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 8, 19, 0, 9, 20, 0, 10, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 11 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 12> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 12-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 1) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4, 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 12-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4, 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 12-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4, 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 12-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 11) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4, 16, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 12 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 13> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 13-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 1) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 2) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 3) << 5,
-    };
-    shifts = simd_batch{ 0, 13, 0, 7, 0, 1, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 13-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 4) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 8, 0, 2, 15, 0, 9, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 13-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 7) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 8) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 16, 0, 10, 0, 4, 17, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 13-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 11) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 12) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 0, 5, 18, 0, 12, 0, 6, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 13 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 14> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 14-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 2) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10, 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 14-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 16, 0, 12, 0, 8, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 14-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10, 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 14-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 11) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 13) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 16, 0, 12, 0, 8, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 14 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 15> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 15-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 15, 0, 13, 0, 11, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 15-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 7, 0, 5, 0, 3, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 15-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 8) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 9) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 10) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 11) << 7,
-    };
-    shifts = simd_batch{ 16, 0, 14, 0, 12, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 15-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 12) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 13) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 14) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 8, 0, 6, 0, 4, 0, 2, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 15 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 16> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 16-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16, 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 16-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16, 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 16-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16, 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 16-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-    };
-    shifts = simd_batch{ 0, 16, 0, 16, 0, 16, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 16 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 17> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 17-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 1) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 2) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 3) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 4) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0, 4, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 17-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 5) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 6) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 7) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 8) << 1,
-    };
-    shifts = simd_batch{ 8, 0, 10, 0, 12, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 17-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 9) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 10) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 11) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 12) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 0, 1, 0, 3, 0, 5, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 17-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 13) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 14) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 15) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 16) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-    };
-    shifts = simd_batch{ 0, 9, 0, 11, 0, 13, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 17 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 18> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 18-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 1) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 2) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0, 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 18-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 5) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6, 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 18-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 10) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 11) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 13) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0, 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 18-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 15) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6, 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 18 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 19> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 19-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 1) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 2) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 3) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 4) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 0, 6, 0, 12, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 19-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 5) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 6) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 7) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 8) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 9) << 3,
-    };
-    shifts = simd_batch{ 0, 11, 0, 0, 4, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 19-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 10) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 11) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 12) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 13) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 14) << 11,
-    };
-    shifts = simd_batch{ 0, 3, 0, 9, 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 19-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 15) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 16) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 17) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 18) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-    };
-    shifts = simd_batch{ 8, 0, 0, 1, 0, 7, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 19 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 20> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 20-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 1) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 3) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-    };
-    shifts = simd_batch{ 0, 0, 8, 0, 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 20-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-    };
-    shifts = simd_batch{ 0, 0, 8, 0, 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 20-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 11) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 12) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 13) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 14) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 8, 0, 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 20-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 16) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 18) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-    };
-    shifts = simd_batch{ 0, 0, 8, 0, 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 20 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 21> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 21-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 1) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 1),
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 2) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 4) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 5) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0, 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 21-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 9) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 10) << 5,
-    };
-    shifts = simd_batch{ 8, 0, 0, 7, 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 21-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 13) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 14) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 15) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-    };
-    shifts = simd_batch{ 0, 5, 0, 0, 4, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 21-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 17) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 18) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 19) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 20) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 2, 0, 0, 1, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 21 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 22> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 22-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 1) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 2) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 3) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 4) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 5) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 2, 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 22-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 6) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 7) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 8) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-    };
-    shifts = simd_batch{ 0, 6, 0, 0, 8, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 22-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 12) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 13) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 14) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 15) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 16) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 2, 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 22-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 17) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 18) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 19) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 20) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 21) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-    };
-    shifts = simd_batch{ 0, 6, 0, 0, 8, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 22 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 23> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 23-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 1) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 2) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 3) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 4) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 5) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5, 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 23-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 6) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 7) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 8) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 9) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 10) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 11) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0, 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 23-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 12) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 13) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 14) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 15) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 16) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 17) << 15,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0, 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 23-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 18) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 19) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 20) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 21) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 22) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 22),
-    };
-    shifts = simd_batch{ 8, 0, 0, 0, 4, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 23 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 24> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 24-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 1) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 2) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 2),
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 5) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8, 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 24-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8, 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 24-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 13) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 17) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8, 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 24-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18),
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 20) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 22) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 23) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 23),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8, 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 24 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 25> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 25-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 1) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 2) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 3) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 3),
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 4) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 6) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 25-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 7) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 8) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 9) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 10) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 11) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 12) << 9,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0, 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 25-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 13) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 14) << 23,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 15) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 16) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 17) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 18) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0, 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 25-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 20) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 21) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 22) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 23) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 24) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 24),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3, 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 25 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 26> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 26-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 1) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 2) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 3) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 4) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 4),
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 5) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 6) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 26-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 7) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 8) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 8),
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 9) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 10) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 11) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 12) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 12),
-    };
-    shifts = simd_batch{ 0, 0, 4, 0, 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 26-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 14) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 15) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 16) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 17) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 17),
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 18) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 19) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 26-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 20) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 21) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 22) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 23) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 24) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 25) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 25),
-    };
-    shifts = simd_batch{ 0, 0, 4, 0, 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 26 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 27> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 27-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 1) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 2) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 3) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 4) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 5) << 25,
-      SafeLoadAs<uint32_t>(in + 4 * 5),
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 6) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 27-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 7) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 8) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 9) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 10) << 23,
-      SafeLoadAs<uint32_t>(in + 4 * 10),
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 11) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 12) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 13) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 27-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 14) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 15) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 16) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 16),
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 18) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 19) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 20) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 0, 1, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 27-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 21) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 22) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 23) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 24) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 25) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 26) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 26),
-    };
-    shifts = simd_batch{ 0, 3, 0, 0, 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 27 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 28> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0xfffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 28-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 1) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 2) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 3) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 4) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 5) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 6) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 6),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 28-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7),
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 8) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 9) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 10) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 11) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 12) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 13) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 13),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 28-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 15) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 16) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 17) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 18) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 19) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 20) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 28-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21),
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 22) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 23) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 24) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 25) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 26) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 27) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 27),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 28 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 29> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x1fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 29-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 1) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 2) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 3) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 4) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 5) << 15,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 6) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 7) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 29-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 8) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 5 | SafeLoadAs<uint32_t>(in + 4 * 9) << 27,
-      SafeLoadAs<uint32_t>(in + 4 * 9),
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 10) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 11) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 12) << 7,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 13) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 14) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 29-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 15) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 16) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 17) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 18) << 25,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 19) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 19),
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 20) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 21) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 29-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 22) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 23) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 24) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 25) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 26) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 27) << 23,
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 28) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 28),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 29 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 30> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x3fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 30-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 1) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 2) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 3) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 4) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 5) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 6) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 7) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 30-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 8) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 9) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 10) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 11) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 12) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 13) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 14) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 30-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15),
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 16) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 17) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 18) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 19) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 20) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 21) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 22) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 30-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 23) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 24) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 25) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 26) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 27) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 28) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 28) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 29) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 29),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 30 * 4;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint32_t, 31> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint32_t, 8>;
-  static constexpr int kValuesUnpacked = 32;
-
-  static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
-    constexpr uint32_t kMask = 0x7fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 31-bit bundles 0 to 7
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 0),
-      SafeLoadAs<uint32_t>(in + 4 * 0) >> 31 | SafeLoadAs<uint32_t>(in + 4 * 1) << 1,
-      SafeLoadAs<uint32_t>(in + 4 * 1) >> 30 | SafeLoadAs<uint32_t>(in + 4 * 2) << 2,
-      SafeLoadAs<uint32_t>(in + 4 * 2) >> 29 | SafeLoadAs<uint32_t>(in + 4 * 3) << 3,
-      SafeLoadAs<uint32_t>(in + 4 * 3) >> 28 | SafeLoadAs<uint32_t>(in + 4 * 4) << 4,
-      SafeLoadAs<uint32_t>(in + 4 * 4) >> 27 | SafeLoadAs<uint32_t>(in + 4 * 5) << 5,
-      SafeLoadAs<uint32_t>(in + 4 * 5) >> 26 | SafeLoadAs<uint32_t>(in + 4 * 6) << 6,
-      SafeLoadAs<uint32_t>(in + 4 * 6) >> 25 | SafeLoadAs<uint32_t>(in + 4 * 7) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 31-bit bundles 8 to 15
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 7) >> 24 | SafeLoadAs<uint32_t>(in + 4 * 8) << 8,
-      SafeLoadAs<uint32_t>(in + 4 * 8) >> 23 | SafeLoadAs<uint32_t>(in + 4 * 9) << 9,
-      SafeLoadAs<uint32_t>(in + 4 * 9) >> 22 | SafeLoadAs<uint32_t>(in + 4 * 10) << 10,
-      SafeLoadAs<uint32_t>(in + 4 * 10) >> 21 | SafeLoadAs<uint32_t>(in + 4 * 11) << 11,
-      SafeLoadAs<uint32_t>(in + 4 * 11) >> 20 | SafeLoadAs<uint32_t>(in + 4 * 12) << 12,
-      SafeLoadAs<uint32_t>(in + 4 * 12) >> 19 | SafeLoadAs<uint32_t>(in + 4 * 13) << 13,
-      SafeLoadAs<uint32_t>(in + 4 * 13) >> 18 | SafeLoadAs<uint32_t>(in + 4 * 14) << 14,
-      SafeLoadAs<uint32_t>(in + 4 * 14) >> 17 | SafeLoadAs<uint32_t>(in + 4 * 15) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 31-bit bundles 16 to 23
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 15) >> 16 | SafeLoadAs<uint32_t>(in + 4 * 16) << 16,
-      SafeLoadAs<uint32_t>(in + 4 * 16) >> 15 | SafeLoadAs<uint32_t>(in + 4 * 17) << 17,
-      SafeLoadAs<uint32_t>(in + 4 * 17) >> 14 | SafeLoadAs<uint32_t>(in + 4 * 18) << 18,
-      SafeLoadAs<uint32_t>(in + 4 * 18) >> 13 | SafeLoadAs<uint32_t>(in + 4 * 19) << 19,
-      SafeLoadAs<uint32_t>(in + 4 * 19) >> 12 | SafeLoadAs<uint32_t>(in + 4 * 20) << 20,
-      SafeLoadAs<uint32_t>(in + 4 * 20) >> 11 | SafeLoadAs<uint32_t>(in + 4 * 21) << 21,
-      SafeLoadAs<uint32_t>(in + 4 * 21) >> 10 | SafeLoadAs<uint32_t>(in + 4 * 22) << 22,
-      SafeLoadAs<uint32_t>(in + 4 * 22) >> 9 | SafeLoadAs<uint32_t>(in + 4 * 23) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    // extract 31-bit bundles 24 to 31
-    words = simd_batch{
-      SafeLoadAs<uint32_t>(in + 4 * 23) >> 8 | SafeLoadAs<uint32_t>(in + 4 * 24) << 24,
-      SafeLoadAs<uint32_t>(in + 4 * 24) >> 7 | SafeLoadAs<uint32_t>(in + 4 * 25) << 25,
-      SafeLoadAs<uint32_t>(in + 4 * 25) >> 6 | SafeLoadAs<uint32_t>(in + 4 * 26) << 26,
-      SafeLoadAs<uint32_t>(in + 4 * 26) >> 5 | SafeLoadAs<uint32_t>(in + 4 * 27) << 27,
-      SafeLoadAs<uint32_t>(in + 4 * 27) >> 4 | SafeLoadAs<uint32_t>(in + 4 * 28) << 28,
-      SafeLoadAs<uint32_t>(in + 4 * 28) >> 3 | SafeLoadAs<uint32_t>(in + 4 * 29) << 29,
-      SafeLoadAs<uint32_t>(in + 4 * 29) >> 2 | SafeLoadAs<uint32_t>(in + 4 * 30) << 30,
-      SafeLoadAs<uint32_t>(in + 4 * 30),
-    };
-    shifts = simd_batch{ 0, 0, 0, 0, 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 8;
-
-    in += 31 * 4;
-    return in;
-  }
-};
-
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 1> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 1-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 1, 2, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 4, 5, 6, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 8, 9, 10, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 13, 14, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 17, 18, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 21, 22, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 25, 26, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 29, 30, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 33, 34, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 37, 38, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 41, 42, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 44, 45, 46, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 49, 50, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 52, 53, 54, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 56, 57, 58, 59 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 1-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 60, 61, 62, 63 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 1 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 2> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 2-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 34, 36, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 42, 44, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 50, 52, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 56, 58, 60, 62 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 2, 4, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 10, 12, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 18, 20, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 24, 26, 28, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 34, 36, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 40, 42, 44, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 50, 52, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 2-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 56, 58, 60, 62 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 2 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 3> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 3-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 3, 6, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 12, 15, 18, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 27, 30, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 36, 39, 42, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 51, 54, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 60, 0, 2, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 11, 14, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 23, 26, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 35, 38, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 47, 50, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 56, 59, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 7, 10, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 19, 22, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 28, 31, 34, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 43, 46, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 3-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 52, 55, 58, 61 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 3 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 4> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xf;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 4-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 36, 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 48, 52, 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 36, 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 52, 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 36, 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 48, 52, 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 4, 8, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 16, 20, 24, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 36, 40, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 4-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 52, 56, 60 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 4 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 5> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 5-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 5, 10, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 20, 25, 30, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 40, 45, 50, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 1, 6, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 21, 26, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 36, 41, 46, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 2) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 56, 0, 2, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 17, 22, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 37, 42, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 52, 57, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 13, 18, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 28, 33, 38, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 48, 53, 58, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 9, 14, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 29, 34, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 5-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 44, 49, 54, 59 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 5 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 6> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 6-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 24, 30, 36, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 54, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 38, 44, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 56, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 22, 28, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 46, 52, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 6, 12, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 30, 36, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 48, 54, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 14, 20, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 38, 44, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 5) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 56, 0, 4, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 22, 28, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 6-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 40, 46, 52, 58 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 6 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 7> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7f;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 7-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 7, 14, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 28, 35, 42, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 56, 0, 6, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 20, 27, 34, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 48, 55, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 19, 26, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 40, 47, 54, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 4, 11, 18, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 39, 46, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 3, 10, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 31, 38, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 52, 0, 2, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 23, 30, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 44, 51, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 8, 15, 22, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 7-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 36, 43, 50, 57 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 7 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 8> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 8-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 8, 16, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 8-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 40, 48, 56 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 8 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 9> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 9-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 9, 18, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 36, 45, 54, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 8, 17, 26, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 44, 53, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 25, 34, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 52, 0, 6, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 33, 42, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 5, 14, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 32, 41, 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 4, 13, 22, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 40, 49, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 21, 30, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 48, 0, 2, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 20, 29, 38, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 1, 10, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 9-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 37, 46, 55 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 9 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 10> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 10-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 10, 20, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 40, 50, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 16, 26, 36, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-    };
-    shifts = simd_batch{ 32, 42, 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 8, 18, 28, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 48, 0, 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 34, 44, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 10, 20, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 40, 50, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 26, 36, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2, 12, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-    };
-    shifts = simd_batch{ 32, 42, 52, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 18, 28, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 48, 0, 4, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 10-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 24, 34, 44, 54 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 10 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 11> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 11-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 11, 22, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 1) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 44, 0, 2, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 2) << 7,
-    };
-    shifts = simd_batch{ 24, 35, 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 4, 15, 26, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 3) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 48, 0, 6, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 4) << 3,
-    };
-    shifts = simd_batch{ 28, 39, 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 19, 30, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 5) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 52, 0, 10, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 43, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 12, 23, 34, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 3, 14, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 36, 47, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 27, 38, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 7, 18, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 40, 51, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 11-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 20, 31, 42, 53 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 11 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 12> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 12-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 12, 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 48, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 44, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 28, 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 12, 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 48, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 44, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 28, 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 12, 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 7) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 48, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 32, 44, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 16, 28, 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 12, 24, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 10) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 48, 0, 8, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 32, 44, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 12-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 16, 28, 40, 52 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 12 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 13> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 13-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 13, 26, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 1, 14, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 2) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 40, 0, 2, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 28, 41, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 4) << 9,
-    };
-    shifts = simd_batch{ 16, 29, 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 4, 17, 30, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 5, 18, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 6) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 44, 0, 6, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 32, 45, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 8) << 5,
-    };
-    shifts = simd_batch{ 20, 33, 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 21, 34, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 9, 22, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 10) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 48, 0, 10, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 36, 49, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 12) << 1,
-    };
-    shifts = simd_batch{ 24, 37, 50, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 13-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 12, 25, 38, 51 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 13 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 14> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 14-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 14, 28, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 6, 20, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 48, 0, 12, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 40, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 32, 46, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 24, 38, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 16, 30, 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 8, 22, 36, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 14, 28, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 6, 20, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 9) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 48, 0, 12, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 40, 0, 4, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 32, 46, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 24, 38, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 13) << 6,
-    };
-    shifts = simd_batch{ 16, 30, 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 14-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 8, 22, 36, 50 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 14 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 15> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 15-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 15, 30, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 11, 26, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 7, 22, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 3, 18, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 48, 0, 14, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 44, 0, 10, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 6) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 40, 0, 6, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 7) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 36, 0, 2, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 32, 47, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 28, 43, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 24, 39, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 20, 35, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 16, 31, 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 12, 27, 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 14) << 11,
-    };
-    shifts = simd_batch{ 8, 23, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 15-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 4, 19, 34, 49 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 15 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 16> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 16-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 16-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 16, 32, 48 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 16 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 17> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 17-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 1) << 13,
-    };
-    shifts = simd_batch{ 0, 17, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 2) << 9,
-    };
-    shifts = simd_batch{ 4, 21, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 3) << 5,
-    };
-    shifts = simd_batch{ 8, 25, 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-    };
-    shifts = simd_batch{ 12, 29, 46, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 16, 33, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 20, 37, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 24, 41, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 28, 45, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 32, 0, 2, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 10) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 36, 0, 6, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 11) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 40, 0, 10, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 44, 0, 14, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 1, 18, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 5, 22, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 9, 26, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 17-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 13, 30, 47 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 17 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 18> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 18-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-    };
-    shifts = simd_batch{ 0, 18, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 8, 26, 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 16, 34, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 42, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 0, 4, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 40, 0, 12, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 2, 20, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 10, 28, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 0, 18, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-    };
-    shifts = simd_batch{ 8, 26, 44, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 16, 34, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 24, 42, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 32, 0, 4, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 15) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 40, 0, 12, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 2, 20, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 18-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 10, 28, 46 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 18 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 19> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 19-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 1) << 7,
-    };
-    shifts = simd_batch{ 0, 19, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 12, 31, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 24, 43, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 4) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 36, 0, 10, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 5) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 3, 22, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 7) << 11,
-    };
-    shifts = simd_batch{ 0, 15, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 8, 27, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 20, 39, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 32, 0, 6, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 11) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 44, 0, 18, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 13) << 15,
-    };
-    shifts = simd_batch{ 0, 11, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 14) << 3,
-    };
-    shifts = simd_batch{ 4, 23, 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 16, 35, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 16) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 28, 0, 2, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 17) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 40, 0, 14, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 19-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 7, 26, 45 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 19 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 20> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 20-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-    };
-    shifts = simd_batch{ 0, 20, 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 16, 36, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 32, 0, 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 4, 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-    };
-    shifts = simd_batch{ 0, 20, 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 16, 36, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 32, 0, 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 4, 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-    };
-    shifts = simd_batch{ 0, 20, 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 16, 36, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 13) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 32, 0, 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 4, 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-    };
-    shifts = simd_batch{ 0, 20, 40, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 16, 36, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 32, 0, 8, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 20-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 4, 24, 44 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 20 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 21> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 21-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-    };
-    shifts = simd_batch{ 0, 21, 42, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 20, 41, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 40, 0, 18, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 0, 17, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 37, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 36, 0, 14, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-    };
-    shifts = simd_batch{ 0, 13, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 12, 33, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 32, 0, 10, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-    };
-    shifts = simd_batch{ 0, 9, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 8, 29, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 28, 0, 6, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-    };
-    shifts = simd_batch{ 0, 5, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 4, 25, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 24, 0, 2, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 21-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 1, 22, 43 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 21 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 22> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 22-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 1) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 22, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 2) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 24, 0, 4, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 3) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 4) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 8, 30, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 32, 0, 12, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-    };
-    shifts = simd_batch{ 0, 14, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 16, 38, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 40, 0, 20, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 22, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 13) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 24, 0, 4, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 15) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 8, 30, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 17) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 32, 0, 12, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 19) << 6,
-    };
-    shifts = simd_batch{ 0, 14, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 16, 38, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 22-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 21) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 40, 0, 20, 42 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 22 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 23> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 23-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 1) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 23, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 2) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 28, 0, 10, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 3) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 4) << 3,
-    };
-    shifts = simd_batch{ 0, 15, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 5) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 20, 0, 2, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 6) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 7) << 11,
-    };
-    shifts = simd_batch{ 0, 7, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 12, 35, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 9) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 10) << 19,
-    };
-    shifts = simd_batch{ 40, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 4, 27, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 12) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 32, 0, 14, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 19, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 15) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 24, 0, 6, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 17) << 7,
-    };
-    shifts = simd_batch{ 0, 11, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 16, 39, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 20) << 15,
-    };
-    shifts = simd_batch{ 0, 3, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 8, 31, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 23-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 22) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 36, 0, 18, 41 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 23 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 24> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 24-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 1) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 14) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 20) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 24, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 24-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 23) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 32, 0, 16, 40 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 24 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 25> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 25-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 1) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 25, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 2) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 3) << 17,
-    };
-    shifts = simd_batch{ 36, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 8, 33, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 6) << 9,
-    };
-    shifts = simd_batch{ 0, 5, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 7) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 16, 0, 2, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 9) << 1,
-    };
-    shifts = simd_batch{ 0, 13, 38, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 10) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 24, 0, 10, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 21, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 14) << 21,
-    };
-    shifts = simd_batch{ 32, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 4, 29, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 17) << 13,
-    };
-    shifts = simd_batch{ 0, 1, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 12, 37, 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 20) << 5,
-    };
-    shifts = simd_batch{ 0, 9, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 21) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 20, 0, 6, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 17, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 25-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 24) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 28, 0, 14, 39 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 25 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 26> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 26-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 26, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 2) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 3) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 4) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 16, 0, 4, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-    };
-    shifts = simd_batch{ 32, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 8, 34, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-    };
-    shifts = simd_batch{ 0, 10, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 24, 0, 12, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 26, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 16) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 17) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 16, 0, 4, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 18, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 20) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-    };
-    shifts = simd_batch{ 32, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 8, 34, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 24) << 2,
-    };
-    shifts = simd_batch{ 0, 10, 36, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 26-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 25) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 24, 0, 12, 38 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 26 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 27> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 27-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 27, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 0, 7, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 4) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 5) << 23,
-    };
-    shifts = simd_batch{ 24, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 4, 31, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 8) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 11, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 10) << 19,
-    };
-    shifts = simd_batch{ 28, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 8, 35, 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 15, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 14) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 32, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 16) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 12, 0, 2, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 19, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 19) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 20) << 11,
-    };
-    shifts = simd_batch{ 36, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 16, 0, 6, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 23) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 23, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 25) << 7,
-    };
-    shifts = simd_batch{ 0, 3, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 27-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 26) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 20, 0, 10, 37 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 27 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 28> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 28-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 28, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 2) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-    };
-    shifts = simd_batch{ 32, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 16, 0, 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 28, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-    };
-    shifts = simd_batch{ 32, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 16, 0, 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 28, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 18) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 19) << 12,
-    };
-    shifts = simd_batch{ 32, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 16, 0, 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 28, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 12, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 26) << 12,
-    };
-    shifts = simd_batch{ 32, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 28-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 27) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 16, 0, 8, 36 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 28 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 29> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 29-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 1) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 29, 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 2) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 3) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 17, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 4) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 5) << 1,
-    };
-    shifts = simd_batch{ 0, 5, 34, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 6) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 7) << 13,
-    };
-    shifts = simd_batch{ 28, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 8) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 9) << 25,
-    };
-    shifts = simd_batch{ 16, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 4, 33, 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 21, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 9, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 15) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 16) << 9,
-    };
-    shifts = simd_batch{ 32, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 17) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 18) << 21,
-    };
-    shifts = simd_batch{ 20, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 19) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 8, 0, 2, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 25, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 13, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 25) << 5,
-    };
-    shifts = simd_batch{ 0, 1, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 26) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 27) << 17,
-    };
-    shifts = simd_batch{ 24, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 29-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 28) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 12, 0, 6, 35 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 29 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 30> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 30-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 30, 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 22, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-    };
-    shifts = simd_batch{ 32, 0, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-    };
-    shifts = simd_batch{ 24, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-    };
-    shifts = simd_batch{ 16, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 8, 0, 4, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 30, 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 22, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 14, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 6, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-    };
-    shifts = simd_batch{ 32, 0, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 25) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-    };
-    shifts = simd_batch{ 24, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 28) << 22,
-    };
-    shifts = simd_batch{ 16, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 30-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 29) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 8, 0, 4, 34 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 30 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 31> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 31-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 1) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 31, 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 2) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 3) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 27, 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 4) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 5) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 23, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 6) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 7) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 19, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 8) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 9) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 15, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 10) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 11) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 11, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 12) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 13) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 7, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 14) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 15) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 3, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 16) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 17) << 3,
-    };
-    shifts = simd_batch{ 32, 0, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 18) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 19) << 7,
-    };
-    shifts = simd_batch{ 28, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 20) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 21) << 11,
-    };
-    shifts = simd_batch{ 24, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 22) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 23) << 15,
-    };
-    shifts = simd_batch{ 20, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 24) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 25) << 19,
-    };
-    shifts = simd_batch{ 16, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 26) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 27) << 23,
-    };
-    shifts = simd_batch{ 12, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 28) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 29) << 27,
-    };
-    shifts = simd_batch{ 8, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 31-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 30) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 4, 0, 2, 33 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 31 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 32> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 32-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 32-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 32, 0, 32 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 32 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 33> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 33-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 1) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 2) << 29,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 3) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 4) << 25,
-    };
-    shifts = simd_batch{ 4, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 5) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 6) << 21,
-    };
-    shifts = simd_batch{ 8, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 7) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-    };
-    shifts = simd_batch{ 12, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-    };
-    shifts = simd_batch{ 16, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 12) << 9,
-    };
-    shifts = simd_batch{ 20, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 14) << 5,
-    };
-    shifts = simd_batch{ 24, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 15) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 16) << 1,
-    };
-    shifts = simd_batch{ 28, 0, 30, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 1, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 5, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 0, 9, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 23) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 24) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 13, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 17, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 28) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 21, 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 30) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 25, 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 33-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 32) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 29, 0, 31 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 33 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 34> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 34-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 1) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 2) << 26,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 3) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 4) << 18,
-    };
-    shifts = simd_batch{ 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 6) << 10,
-    };
-    shifts = simd_batch{ 16, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 7) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-    };
-    shifts = simd_batch{ 24, 0, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 9) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 11) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 18, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 26, 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 19) << 26,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 20) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-    };
-    shifts = simd_batch{ 8, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 22) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 23) << 10,
-    };
-    shifts = simd_batch{ 16, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 25) << 2,
-    };
-    shifts = simd_batch{ 24, 0, 28, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 27) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 2, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 28) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 10, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 30) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 31) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 18, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 34-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 33) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 26, 0, 30 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 34 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 35> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 35-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 1) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 2) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 3) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 4) << 11,
-    };
-    shifts = simd_batch{ 12, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 6) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 24, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 8) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 7, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 0, 19, 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 12) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 13) << 27,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 14) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 8, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 16) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 17) << 3,
-    };
-    shifts = simd_batch{ 20, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 19) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 3, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 21) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 15, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 24) << 31,
-    };
-    shifts = simd_batch{ 0, 27, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 26) << 19,
-    };
-    shifts = simd_batch{ 4, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 27) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 28) << 7,
-    };
-    shifts = simd_batch{ 16, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 29) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 28, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 32) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 11, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 35-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 34) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 23, 0, 29 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 35 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 36> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 36-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 1) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-    };
-    shifts = simd_batch{ 16, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 5) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 20, 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-    };
-    shifts = simd_batch{ 16, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 20, 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 21) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-    };
-    shifts = simd_batch{ 16, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 26) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 20, 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 30) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-    };
-    shifts = simd_batch{ 16, 0, 24, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 33) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 4, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 36-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 35) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 20, 0, 28 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 36 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 37> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 37-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 1) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 2) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 3) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 4) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 20, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 5) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 6) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 13, 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 7) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 8) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 9) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 10) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 11) << 1,
-    };
-    shifts = simd_batch{ 16, 0, 26, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 12) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 13) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 9, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 14) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 15) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 16) << 25,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 17) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 18) << 5,
-    };
-    shifts = simd_batch{ 12, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 19) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 20) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 5, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 21) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 22) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 23) << 29,
-    };
-    shifts = simd_batch{ 0, 25, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 24) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 25) << 9,
-    };
-    shifts = simd_batch{ 8, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 26) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 27) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 1, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 28) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 29) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 30) << 33,
-    };
-    shifts = simd_batch{ 0, 21, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 31) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 32) << 13,
-    };
-    shifts = simd_batch{ 4, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 33) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 34) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 24, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 37-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 35) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 36) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-    };
-    shifts = simd_batch{ 0, 17, 0, 27 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 37 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 38> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 38-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 1) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 3) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 4) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 24, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 5) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 6) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 7) << 30,
-    };
-    shifts = simd_batch{ 0, 22, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 8) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-    };
-    shifts = simd_batch{ 8, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 10) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 6, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 16) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 16, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 0, 14, 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 21) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 22) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 23) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 24, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 24) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 26) << 30,
-    };
-    shifts = simd_batch{ 0, 22, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 28) << 6,
-    };
-    shifts = simd_batch{ 8, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 30) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 6, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 31) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 32) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 33) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 34) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 35) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 16, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 38-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 37) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-    };
-    shifts = simd_batch{ 0, 14, 0, 26 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 38 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 39> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 39-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 1) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 2) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 3) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 4) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 3, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 6) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 7) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 8) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 9) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 20, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 12) << 27,
-    };
-    shifts = simd_batch{ 0, 23, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 14) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 12, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 16) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 17) << 35,
-    };
-    shifts = simd_batch{ 0, 15, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 18) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 19) << 7,
-    };
-    shifts = simd_batch{ 4, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 7, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 23) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 24) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 25) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 24, 0, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 28) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 29) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 30) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 31) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 16, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 32) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 33) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 34) << 31,
-    };
-    shifts = simd_batch{ 0, 19, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 35) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 36) << 3,
-    };
-    shifts = simd_batch{ 8, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 39-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 38) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 11, 0, 25 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 39 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 40> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 40-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 1) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 3) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 11) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 12) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 13) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 24) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 26) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 27) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 29) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 33) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 37) << 8,
-    };
-    shifts = simd_batch{ 0, 0, 16, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 40-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 39) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 8, 0, 24 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 40 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 41> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 41-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 1) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 2) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 3) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 4) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 5) << 33,
-    };
-    shifts = simd_batch{ 0, 13, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 6) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 7) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 8, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 8) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 9) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 10) << 25,
-    };
-    shifts = simd_batch{ 0, 21, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 11) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 12) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 16, 0, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 13) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 14) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 15) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 16) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 17) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 1, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 18) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 19) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 20) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 21) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 22) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 23) << 37,
-    };
-    shifts = simd_batch{ 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 24) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 25) << 1,
-    };
-    shifts = simd_batch{ 4, 0, 22, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 26) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 27) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 28) << 29,
-    };
-    shifts = simd_batch{ 0, 17, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 29) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 30) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 12, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 31) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 32) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 33) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 34) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 35) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 20, 0, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 36) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 37) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 38) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 41-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 39) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 40) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-    };
-    shifts = simd_batch{ 0, 5, 0, 23 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 41 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 42> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 42-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 1) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 1),
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 5) << 26,
-    };
-    shifts = simd_batch{ 0, 18, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-    };
-    shifts = simd_batch{ 16, 0, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 9) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-    };
-    shifts = simd_batch{ 0, 10, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 15) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 8, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 17) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 2, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 20, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-    };
-    shifts = simd_batch{ 0, 18, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 27) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 16, 0, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 31) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-    };
-    shifts = simd_batch{ 0, 10, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 35) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-    };
-    shifts = simd_batch{ 8, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 39) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 42-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 41) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 2, 0, 22 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 42 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 43> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 43-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 1) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 2) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 3) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 4) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 5) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 6) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 7) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 8) << 39,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 9) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 10) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 4, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 11) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 12) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 13) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 14) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 15) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 16) << 35,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 17) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 18) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-    };
-    shifts = simd_batch{ 8, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 19) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 20) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 21) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 22) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 23) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 24) << 31,
-    };
-    shifts = simd_batch{ 0, 11, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 25) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 26) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 12, 0, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 27) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 28) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 29) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 30) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 31) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 32) << 27,
-    };
-    shifts = simd_batch{ 0, 15, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 33) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 34) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 16, 0, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 35) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 36) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 37) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 38) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 39) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 40) << 23,
-    };
-    shifts = simd_batch{ 0, 19, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 43-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 41) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 42) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-    };
-    shifts = simd_batch{ 20, 0, 0, 21 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 43 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 44> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 44-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 1) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 2) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 3) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 4) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 5) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 6) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 8) << 28,
-    };
-    shifts = simd_batch{ 0, 12, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-    };
-    shifts = simd_batch{ 16, 0, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 12) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 13) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 15) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-    };
-    shifts = simd_batch{ 0, 12, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 16, 0, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 23) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 24) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 26) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 30) << 28,
-    };
-    shifts = simd_batch{ 0, 12, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 32) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 16, 0, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 34) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 36) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 37) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 38) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 39) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 40) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 41) << 28,
-    };
-    shifts = simd_batch{ 0, 12, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 44-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 42) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 43) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-    };
-    shifts = simd_batch{ 16, 0, 0, 20 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 44 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 45> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 45-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 1) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 2) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 4) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 7) << 43,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 11) << 29,
-    };
-    shifts = simd_batch{ 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 14) << 41,
-    };
-    shifts = simd_batch{ 16, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 16) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 4, 0, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 18) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 19) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 18, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 21) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 22) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-    };
-    shifts = simd_batch{ 0, 13, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 28) << 37,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 29) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 8, 0, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 32) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 33) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 36) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 38) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 39) << 21,
-    };
-    shifts = simd_batch{ 0, 17, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 41) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 42) << 33,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 45-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 43) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 44) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 12, 0, 0, 19 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 45 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 46> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 46-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 1) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 2) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 3) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 4) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 5) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 6) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 7) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 8) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 9) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 10) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 11) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 12) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 13) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 14) << 22,
-    };
-    shifts = simd_batch{ 0, 14, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 15) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 16) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 17) << 30,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 20) << 38,
-    };
-    shifts = simd_batch{ 16, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-    };
-    shifts = simd_batch{ 8, 0, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 24) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 25) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 26) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 27) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 28) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 29) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 30) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 31) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 32) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 33) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 34) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 35) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 36) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 37) << 22,
-    };
-    shifts = simd_batch{ 0, 14, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 38) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 39) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 40) << 30,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 41) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 42) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 43) << 38,
-    };
-    shifts = simd_batch{ 16, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 46-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 44) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 45) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-    };
-    shifts = simd_batch{ 8, 0, 0, 18 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 46 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 47> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 47-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 1) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 2) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 3) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 4) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 5) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 6) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 7) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 8) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 9) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 10) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 11) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 12) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 13) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 14) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 15) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 16) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 17) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 18) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 19) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 20) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 21) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 22) << 45,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 23) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 24) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 25) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 26) << 19,
-    };
-    shifts = simd_batch{ 0, 15, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 27) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 28) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 29) << 23,
-    };
-    shifts = simd_batch{ 0, 11, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 30) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 31) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 32) << 27,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 33) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 34) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 35) << 31,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 36) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 37) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 38) << 35,
-    };
-    shifts = simd_batch{ 16, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 39) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 40) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 41) << 39,
-    };
-    shifts = simd_batch{ 12, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 42) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 43) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 44) << 43,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 47-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 45) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 46) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 46),
-    };
-    shifts = simd_batch{ 4, 0, 0, 17 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 47 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 48> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 48-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 1) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 2) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 2),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 5) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 17) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 25) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 28) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 31) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 35) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 40) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 41) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 43) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 44) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 48-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 46) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 47) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 0, 0, 16 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 48 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 49> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 49-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 1) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 2) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 3) << 45,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 4) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 5) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 6) << 41,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 8) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 9) << 37,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 10) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 11) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 12) << 33,
-    };
-    shifts = simd_batch{ 12, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 13) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 15) << 29,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 16) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 17) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 18) << 25,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 20) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-    };
-    shifts = simd_batch{ 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 22) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 22),
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 23) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 24) << 17,
-    };
-    shifts = simd_batch{ 0, 13, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 25) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 26) << 47,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 27) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 29) << 43,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 30) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 32) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 33) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 34) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 36) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 14, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 38) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 39) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 40) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 41) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-    };
-    shifts = simd_batch{ 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 43) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 44) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 45) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-    };
-    shifts = simd_batch{ 0, 0, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 49-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 46) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 47) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 48) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 0, 0, 15 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 49 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 50> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 50-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 1) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 2) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 3) << 42,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 4) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 6) << 34,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 7) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 8) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 9) << 26,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 10) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 11) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 12) << 18,
-    };
-    shifts = simd_batch{ 0, 10, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 13) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 14) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 15) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 16) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 17) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 18) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 20) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 21) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 24) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 0, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 27) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 28) << 42,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 29) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 30) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 31) << 34,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 32) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 34) << 26,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 36) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 37) << 18,
-    };
-    shifts = simd_batch{ 0, 10, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 39) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 40) << 10,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 41) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 42) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 43) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 12, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 44) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 45) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 46) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 46),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 50-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 47) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 48) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 49) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 49),
-    };
-    shifts = simd_batch{ 0, 0, 0, 14 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 50 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 51> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 51-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 1) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 2) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 3) << 39,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3),
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 4) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 5) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 6) << 27,
-    };
-    shifts = simd_batch{ 12, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 7) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 8) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 9) << 15,
-    };
-    shifts = simd_batch{ 0, 11, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 10) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 11) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 12) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 13) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 14) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 15) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-    };
-    shifts = simd_batch{ 0, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 18) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 19) << 43,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 20) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 21) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 22) << 31,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 23) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 24) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 25) << 19,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 26) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 27) << 45,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 28) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 30) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 31) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 33) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 35) << 47,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 36) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 37) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 38) << 35,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 39) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 40) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 41) << 23,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 42) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 43) << 49,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 44) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 45) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 46) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 47) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 51-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 48) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 49) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 50) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 50),
-    };
-    shifts = simd_batch{ 0, 0, 0, 13 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 51 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 52> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 52-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 1) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 2) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 3) << 36,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 4) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 5) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 6) << 20,
-    };
-    shifts = simd_batch{ 0, 4, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 7) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 8) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 9) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 10) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 11) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 12) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-    };
-    shifts = simd_batch{ 0, 0, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 14) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 15) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 16) << 36,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 17) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 17),
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 18) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 19) << 20,
-    };
-    shifts = simd_batch{ 0, 4, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 20) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 21) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 25) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 25),
-    };
-    shifts = simd_batch{ 0, 0, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 27) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 28) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 29) << 36,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 30) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 31) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 32) << 20,
-    };
-    shifts = simd_batch{ 0, 4, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 33) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 34) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 35) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 36) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 38) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-    };
-    shifts = simd_batch{ 0, 0, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39),
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 40) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 41) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 42) << 36,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 43) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 44) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 45) << 20,
-    };
-    shifts = simd_batch{ 0, 4, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 46) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 47) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 48) << 4,
-    };
-    shifts = simd_batch{ 0, 0, 8, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 52-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 49) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 50) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 51) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 51),
-    };
-    shifts = simd_batch{ 0, 0, 0, 12 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 52 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 53> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 53-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 1) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 2) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 3) << 33,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 4) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 4),
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 5) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 6) << 13,
-    };
-    shifts = simd_batch{ 0, 9, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 7) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 8) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 9) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-    };
-    shifts = simd_batch{ 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 10) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 11) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 12) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 13) << 37,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 14) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 15) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 16) << 17,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 17) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 18) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 19) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 20) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 21) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 22) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 23) << 41,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 24) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 25) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 26) << 21,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 27) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 28) << 43,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 29) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 10, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 30) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 31) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 32) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 33) << 45,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33),
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 34) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 35) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 36) << 25,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 37) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 38) << 47,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 39) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 40) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 41) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 42) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 43) << 49,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 44) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 45) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 46) << 29,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 47) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 48) << 51,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 49) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 53-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 50) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 51) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 52) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 52),
-    };
-    shifts = simd_batch{ 0, 0, 0, 11 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 53 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 54> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 54-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 1) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 2) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 3) << 30,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 4) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 5) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 5),
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 7) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 8) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 10) << 46,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10),
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 11) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 13) << 22,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 14) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 15) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 16) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 19) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 20) << 38,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 21) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 22) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 23) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 25) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 26),
-    };
-    shifts = simd_batch{ 0, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 28) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 29) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 31) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 32) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 33) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 35) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 37) << 46,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37),
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 38) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 39) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 40) << 22,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 41) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 43) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 43),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 44) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 45) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 46) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 47) << 38,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 49) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 50) << 14,
-    };
-    shifts = simd_batch{ 0, 6, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 54-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 51) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 52) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 53) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 53),
-    };
-    shifts = simd_batch{ 0, 0, 0, 10 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 54 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 55> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 55-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 1) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 2) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 3) << 27,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 4) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 5) << 45,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 6) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 7) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 8) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 9) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 10) << 35,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 11) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 12) << 53,
-      SafeLoadAs<uint64_t>(in + 8 * 12),
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 13) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 14) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 15) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 16) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 17) << 43,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 18) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 18),
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 19) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 20) << 15,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 22) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 23) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 24) << 51,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 25) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 26) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 27) << 23,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 28) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 29) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 30) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 32) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 33) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 34) << 31,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 35) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 36) << 49,
-      SafeLoadAs<uint64_t>(in + 8 * 36),
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 37) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 38) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 39) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 40) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 41) << 39,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 42) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 43) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 44) << 11,
-    };
-    shifts = simd_batch{ 0, 7, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 45) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 46) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 47) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 48) << 47,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 49) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 50) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 51) << 19,
-    };
-    shifts = simd_batch{ 8, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 55-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 52) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 53) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 54) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 54),
-    };
-    shifts = simd_batch{ 0, 0, 0, 9 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 55 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 56> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 56-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 1) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 2) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 3) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 4) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 5) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 6) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 6),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7),
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 9) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 10) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 11) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 12) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 13) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 13),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 15) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 17) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 18) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 19) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 20) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21),
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 22) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 23) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 25) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 26) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 27) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 27),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 29) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 30) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 31) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 33) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 34) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 34),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 36) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 37) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 38) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 39) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 41) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 41),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42),
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 43) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 44) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 45) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 46) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 47) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49),
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 50) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 51) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 52) << 24,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 56-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 53) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 54) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 55) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 55),
-    };
-    shifts = simd_batch{ 0, 0, 0, 8 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 56 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 57> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 57-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 1) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 2) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 3) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 4) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 5) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 6) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 7) << 49,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 8) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 8),
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 9) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 10) << 13,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 11) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 12) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 13) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 14) << 41,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 15) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 16) << 55,
-      SafeLoadAs<uint64_t>(in + 8 * 16),
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 17) << 5,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 20) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 21) << 33,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 22) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 23) << 47,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 24) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 24),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 25) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 26) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 27) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 28) << 25,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 29) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 30) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 31) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 32) << 53,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32),
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 33) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 34) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 35) << 17,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 37) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 39) << 45,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 40) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 41) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 42) << 9,
-    };
-    shifts = simd_batch{ 0, 5, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 43) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 44) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 45) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 46) << 37,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 47) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 48) << 51,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 49) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 6, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 50) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 51) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 52) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 53) << 29,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 57-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 54) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 55) << 43,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 56) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 56),
-    };
-    shifts = simd_batch{ 0, 0, 0, 7 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 57 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 58> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 58-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 1) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 2) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 3) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 4) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 5) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 6) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 7) << 42,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 8) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 9) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 9),
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 10) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 11) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 12) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 13) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 14) << 26,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 15) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 16) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 17) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 18) << 50,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 19) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 19),
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 20) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 21) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 22) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 23) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 24) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 25) << 34,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 26) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 27) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 28) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 28),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 30) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 31) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 32) << 18,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 33) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 34) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 35) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 36) << 42,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 37) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 38) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 38),
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 39) << 2,
-    };
-    shifts = simd_batch{ 0, 0, 4, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 40) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 41) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 42) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 43) << 26,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 44) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 45) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 46) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 47) << 50,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 48) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 48),
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 49) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 50) << 10,
-    };
-    shifts = simd_batch{ 0, 2, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 51) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 52) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 53) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 54) << 34,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 58-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 55) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 56) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 57) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 57),
-    };
-    shifts = simd_batch{ 0, 0, 0, 6 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 58 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 59> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7ffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 59-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 1) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 2) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 3) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 4) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 5) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 6) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 7) << 35,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 8) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 9) << 45,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 10) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 11) << 55,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11),
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 12) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 13) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 14) << 11,
-    };
-    shifts = simd_batch{ 4, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 15) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 16) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 17) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 18) << 31,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 19) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 20) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 21) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 22) << 51,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 23) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 23),
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 24) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 25) << 7,
-    };
-    shifts = simd_batch{ 0, 3, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 26) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 27) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 28) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 29) << 27,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 30) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 31) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 32) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 33) << 47,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 34) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 35) << 57,
-      SafeLoadAs<uint64_t>(in + 8 * 35),
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 36) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 37) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 38) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 39) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 40) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 41) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 42) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 43) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 44) << 43,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 45) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 46) << 53,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 47) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 47),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 48) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 49) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 50) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 51) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 52) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 53) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 54) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 55) << 39,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 59-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 56) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 57) << 49,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 58) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 58),
-    };
-    shifts = simd_batch{ 0, 0, 0, 5 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 59 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 60> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0xfffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 60-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 1) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 2) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 3) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 4) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 5) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 6) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 7) << 28,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 8) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 9) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 10) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 11) << 44,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 12) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 13) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 14) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 14),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15),
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 16) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 17) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 18) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 19) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 21) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 22) << 28,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 23) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 24) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 25) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 26) << 44,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 27) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 28) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 29) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 29),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 31) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 32) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 33) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 34) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 35) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 36) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 37) << 28,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 38) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 39) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 41) << 44,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 42) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 43) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 44) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 44),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45),
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 46) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 47) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 48) << 12,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 49) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 50) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 51) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 52) << 28,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 53) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 54) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 55) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 56) << 44,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 60-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 57) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 58) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 59) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 59),
-    };
-    shifts = simd_batch{ 0, 0, 0, 4 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 60 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 61> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x1fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 61-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 1) << 3,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 2) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 3) << 9,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 4) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 5) << 15,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 6) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 7) << 21,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 8) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 9) << 27,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 10) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 11) << 33,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 12) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 13) << 39,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 14) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 15) << 45,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 16) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 17) << 51,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 18) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 19) << 57,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 20) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 20),
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 21) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 22) << 5,
-    };
-    shifts = simd_batch{ 0, 1, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 23) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 24) << 11,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 25) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 26) << 17,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 27) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 28) << 23,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 29) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 30) << 29,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 31) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 32) << 35,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 33) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 34) << 41,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 35) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 36) << 47,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 37) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 38) << 53,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 39) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 5 | SafeLoadAs<uint64_t>(in + 8 * 40) << 59,
-      SafeLoadAs<uint64_t>(in + 8 * 40),
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 41) << 1,
-    };
-    shifts = simd_batch{ 0, 0, 2, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 42) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 43) << 7,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 44) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 45) << 13,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 46) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 47) << 19,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 48) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 49) << 25,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 50) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 51) << 31,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 52) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 53) << 37,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 54) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 55) << 43,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 56) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 57) << 49,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 61-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 58) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 59) << 55,
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 60) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 60),
-    };
-    shifts = simd_batch{ 0, 0, 0, 3 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 61 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 62> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x3fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 62-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 1) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 2) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 3) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 4) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 5) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 6) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 7) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 8) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 9) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 10) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 11) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 12) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 13) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 14) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 15) << 30,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 16) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 17) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 18) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 19) << 38,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 20) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 21) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 22) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 23) << 46,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 24) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 25) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 26) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 27) << 54,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 28) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 29) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 30) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 30),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31),
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 32) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 33) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 34) << 6,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 35) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 36) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 37) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 38) << 14,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 39) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 40) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 41) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 42) << 22,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 43) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 44) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 45) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 46) << 30,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 47) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 48) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 49) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 50) << 38,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 51) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 52) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 53) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 54) << 46,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 55) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 56) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 57) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 58) << 54,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 62-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 59) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 60) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 60) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 61) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 61),
-    };
-    shifts = simd_batch{ 0, 0, 0, 2 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 62 * 8;
-    return in;
-  }
-};
-
-template<>
-struct Simd256UnpackerForWidth<uint64_t, 63> {
-
-  using simd_batch = xsimd::make_sized_batch_t<uint64_t, 4>;
-  static constexpr int kValuesUnpacked = 64;
-
-  static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
-    constexpr uint64_t kMask = 0x7fffffffffffffff;
-
-    simd_batch masks(kMask);
-    simd_batch words, shifts;
-    simd_batch results;
-    // extract 63-bit bundles 0 to 3
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 0),
-      SafeLoadAs<uint64_t>(in + 8 * 0) >> 63 | SafeLoadAs<uint64_t>(in + 8 * 1) << 1,
-      SafeLoadAs<uint64_t>(in + 8 * 1) >> 62 | SafeLoadAs<uint64_t>(in + 8 * 2) << 2,
-      SafeLoadAs<uint64_t>(in + 8 * 2) >> 61 | SafeLoadAs<uint64_t>(in + 8 * 3) << 3,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 4 to 7
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 3) >> 60 | SafeLoadAs<uint64_t>(in + 8 * 4) << 4,
-      SafeLoadAs<uint64_t>(in + 8 * 4) >> 59 | SafeLoadAs<uint64_t>(in + 8 * 5) << 5,
-      SafeLoadAs<uint64_t>(in + 8 * 5) >> 58 | SafeLoadAs<uint64_t>(in + 8 * 6) << 6,
-      SafeLoadAs<uint64_t>(in + 8 * 6) >> 57 | SafeLoadAs<uint64_t>(in + 8 * 7) << 7,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 8 to 11
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 7) >> 56 | SafeLoadAs<uint64_t>(in + 8 * 8) << 8,
-      SafeLoadAs<uint64_t>(in + 8 * 8) >> 55 | SafeLoadAs<uint64_t>(in + 8 * 9) << 9,
-      SafeLoadAs<uint64_t>(in + 8 * 9) >> 54 | SafeLoadAs<uint64_t>(in + 8 * 10) << 10,
-      SafeLoadAs<uint64_t>(in + 8 * 10) >> 53 | SafeLoadAs<uint64_t>(in + 8 * 11) << 11,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 12 to 15
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 11) >> 52 | SafeLoadAs<uint64_t>(in + 8 * 12) << 12,
-      SafeLoadAs<uint64_t>(in + 8 * 12) >> 51 | SafeLoadAs<uint64_t>(in + 8 * 13) << 13,
-      SafeLoadAs<uint64_t>(in + 8 * 13) >> 50 | SafeLoadAs<uint64_t>(in + 8 * 14) << 14,
-      SafeLoadAs<uint64_t>(in + 8 * 14) >> 49 | SafeLoadAs<uint64_t>(in + 8 * 15) << 15,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 16 to 19
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 15) >> 48 | SafeLoadAs<uint64_t>(in + 8 * 16) << 16,
-      SafeLoadAs<uint64_t>(in + 8 * 16) >> 47 | SafeLoadAs<uint64_t>(in + 8 * 17) << 17,
-      SafeLoadAs<uint64_t>(in + 8 * 17) >> 46 | SafeLoadAs<uint64_t>(in + 8 * 18) << 18,
-      SafeLoadAs<uint64_t>(in + 8 * 18) >> 45 | SafeLoadAs<uint64_t>(in + 8 * 19) << 19,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 20 to 23
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 19) >> 44 | SafeLoadAs<uint64_t>(in + 8 * 20) << 20,
-      SafeLoadAs<uint64_t>(in + 8 * 20) >> 43 | SafeLoadAs<uint64_t>(in + 8 * 21) << 21,
-      SafeLoadAs<uint64_t>(in + 8 * 21) >> 42 | SafeLoadAs<uint64_t>(in + 8 * 22) << 22,
-      SafeLoadAs<uint64_t>(in + 8 * 22) >> 41 | SafeLoadAs<uint64_t>(in + 8 * 23) << 23,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 24 to 27
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 23) >> 40 | SafeLoadAs<uint64_t>(in + 8 * 24) << 24,
-      SafeLoadAs<uint64_t>(in + 8 * 24) >> 39 | SafeLoadAs<uint64_t>(in + 8 * 25) << 25,
-      SafeLoadAs<uint64_t>(in + 8 * 25) >> 38 | SafeLoadAs<uint64_t>(in + 8 * 26) << 26,
-      SafeLoadAs<uint64_t>(in + 8 * 26) >> 37 | SafeLoadAs<uint64_t>(in + 8 * 27) << 27,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 28 to 31
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 27) >> 36 | SafeLoadAs<uint64_t>(in + 8 * 28) << 28,
-      SafeLoadAs<uint64_t>(in + 8 * 28) >> 35 | SafeLoadAs<uint64_t>(in + 8 * 29) << 29,
-      SafeLoadAs<uint64_t>(in + 8 * 29) >> 34 | SafeLoadAs<uint64_t>(in + 8 * 30) << 30,
-      SafeLoadAs<uint64_t>(in + 8 * 30) >> 33 | SafeLoadAs<uint64_t>(in + 8 * 31) << 31,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 32 to 35
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 31) >> 32 | SafeLoadAs<uint64_t>(in + 8 * 32) << 32,
-      SafeLoadAs<uint64_t>(in + 8 * 32) >> 31 | SafeLoadAs<uint64_t>(in + 8 * 33) << 33,
-      SafeLoadAs<uint64_t>(in + 8 * 33) >> 30 | SafeLoadAs<uint64_t>(in + 8 * 34) << 34,
-      SafeLoadAs<uint64_t>(in + 8 * 34) >> 29 | SafeLoadAs<uint64_t>(in + 8 * 35) << 35,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 36 to 39
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 35) >> 28 | SafeLoadAs<uint64_t>(in + 8 * 36) << 36,
-      SafeLoadAs<uint64_t>(in + 8 * 36) >> 27 | SafeLoadAs<uint64_t>(in + 8 * 37) << 37,
-      SafeLoadAs<uint64_t>(in + 8 * 37) >> 26 | SafeLoadAs<uint64_t>(in + 8 * 38) << 38,
-      SafeLoadAs<uint64_t>(in + 8 * 38) >> 25 | SafeLoadAs<uint64_t>(in + 8 * 39) << 39,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 40 to 43
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 39) >> 24 | SafeLoadAs<uint64_t>(in + 8 * 40) << 40,
-      SafeLoadAs<uint64_t>(in + 8 * 40) >> 23 | SafeLoadAs<uint64_t>(in + 8 * 41) << 41,
-      SafeLoadAs<uint64_t>(in + 8 * 41) >> 22 | SafeLoadAs<uint64_t>(in + 8 * 42) << 42,
-      SafeLoadAs<uint64_t>(in + 8 * 42) >> 21 | SafeLoadAs<uint64_t>(in + 8 * 43) << 43,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 44 to 47
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 43) >> 20 | SafeLoadAs<uint64_t>(in + 8 * 44) << 44,
-      SafeLoadAs<uint64_t>(in + 8 * 44) >> 19 | SafeLoadAs<uint64_t>(in + 8 * 45) << 45,
-      SafeLoadAs<uint64_t>(in + 8 * 45) >> 18 | SafeLoadAs<uint64_t>(in + 8 * 46) << 46,
-      SafeLoadAs<uint64_t>(in + 8 * 46) >> 17 | SafeLoadAs<uint64_t>(in + 8 * 47) << 47,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 48 to 51
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 47) >> 16 | SafeLoadAs<uint64_t>(in + 8 * 48) << 48,
-      SafeLoadAs<uint64_t>(in + 8 * 48) >> 15 | SafeLoadAs<uint64_t>(in + 8 * 49) << 49,
-      SafeLoadAs<uint64_t>(in + 8 * 49) >> 14 | SafeLoadAs<uint64_t>(in + 8 * 50) << 50,
-      SafeLoadAs<uint64_t>(in + 8 * 50) >> 13 | SafeLoadAs<uint64_t>(in + 8 * 51) << 51,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 52 to 55
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 51) >> 12 | SafeLoadAs<uint64_t>(in + 8 * 52) << 52,
-      SafeLoadAs<uint64_t>(in + 8 * 52) >> 11 | SafeLoadAs<uint64_t>(in + 8 * 53) << 53,
-      SafeLoadAs<uint64_t>(in + 8 * 53) >> 10 | SafeLoadAs<uint64_t>(in + 8 * 54) << 54,
-      SafeLoadAs<uint64_t>(in + 8 * 54) >> 9 | SafeLoadAs<uint64_t>(in + 8 * 55) << 55,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 56 to 59
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 55) >> 8 | SafeLoadAs<uint64_t>(in + 8 * 56) << 56,
-      SafeLoadAs<uint64_t>(in + 8 * 56) >> 7 | SafeLoadAs<uint64_t>(in + 8 * 57) << 57,
-      SafeLoadAs<uint64_t>(in + 8 * 57) >> 6 | SafeLoadAs<uint64_t>(in + 8 * 58) << 58,
-      SafeLoadAs<uint64_t>(in + 8 * 58) >> 5 | SafeLoadAs<uint64_t>(in + 8 * 59) << 59,
-    };
-    shifts = simd_batch{ 0, 0, 0, 0 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    // extract 63-bit bundles 60 to 63
-    words = simd_batch{
-      SafeLoadAs<uint64_t>(in + 8 * 59) >> 4 | SafeLoadAs<uint64_t>(in + 8 * 60) << 60,
-      SafeLoadAs<uint64_t>(in + 8 * 60) >> 3 | SafeLoadAs<uint64_t>(in + 8 * 61) << 61,
-      SafeLoadAs<uint64_t>(in + 8 * 61) >> 2 | SafeLoadAs<uint64_t>(in + 8 * 62) << 62,
-      SafeLoadAs<uint64_t>(in + 8 * 62),
-    };
-    shifts = simd_batch{ 0, 0, 0, 1 };
-    results = (words >> shifts) & masks;
-    results.store_unaligned(out);
-    out += 4;
-
-    in += 63 * 8;
-    return in;
-  }
-};
-
-
-}  // namespace
-}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_simd512_generated_internal.h b/cpp/src/arrow/util/bpacking_simd512_generated_internal.h
index bb79fbca5b4..263f1d79ff8 100644
--- a/cpp/src/arrow/util/bpacking_simd512_generated_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd512_generated_internal.h
@@ -40,6 +40,7 @@ template<int kBitWidth>
 struct Simd512UnpackerForWidth<bool, kBitWidth> {
 
   static constexpr int kValuesUnpacked = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, bool* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -55,6 +56,7 @@ template<int kBitWidth>
 struct Simd512UnpackerForWidth<uint8_t, kBitWidth> {
 
   static constexpr int kValuesUnpacked = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, uint8_t* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -70,6 +72,7 @@ template<int kBitWidth>
 struct Simd512UnpackerForWidth<uint16_t, kBitWidth> {
 
   static constexpr int kValuesUnpacked = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kValuesUnpacked;
+  static constexpr int kBytesRead = Simd512UnpackerForWidth<uint32_t, kBitWidth>::kBytesRead;
 
   static const uint8_t* unpack(const uint8_t* in, uint16_t* out) {
     uint32_t buffer[kValuesUnpacked] = {};
@@ -86,6 +89,7 @@ struct Simd512UnpackerForWidth<uint32_t, 1> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 4;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1;
@@ -151,6 +155,7 @@ struct Simd512UnpackerForWidth<uint32_t, 2> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 8;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3;
@@ -216,6 +221,7 @@ struct Simd512UnpackerForWidth<uint32_t, 3> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 12;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7;
@@ -281,6 +287,7 @@ struct Simd512UnpackerForWidth<uint32_t, 4> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 16;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xf;
@@ -346,6 +353,7 @@ struct Simd512UnpackerForWidth<uint32_t, 5> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 20;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1f;
@@ -411,6 +419,7 @@ struct Simd512UnpackerForWidth<uint32_t, 6> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 24;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3f;
@@ -476,6 +485,7 @@ struct Simd512UnpackerForWidth<uint32_t, 7> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 28;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7f;
@@ -541,6 +551,7 @@ struct Simd512UnpackerForWidth<uint32_t, 8> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 32;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xff;
@@ -606,6 +617,7 @@ struct Simd512UnpackerForWidth<uint32_t, 9> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 36;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1ff;
@@ -671,6 +683,7 @@ struct Simd512UnpackerForWidth<uint32_t, 10> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 40;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3ff;
@@ -736,6 +749,7 @@ struct Simd512UnpackerForWidth<uint32_t, 11> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 44;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7ff;
@@ -801,6 +815,7 @@ struct Simd512UnpackerForWidth<uint32_t, 12> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 48;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xfff;
@@ -866,6 +881,7 @@ struct Simd512UnpackerForWidth<uint32_t, 13> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 52;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1fff;
@@ -931,6 +947,7 @@ struct Simd512UnpackerForWidth<uint32_t, 14> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 56;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3fff;
@@ -996,6 +1013,7 @@ struct Simd512UnpackerForWidth<uint32_t, 15> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 60;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7fff;
@@ -1061,6 +1079,7 @@ struct Simd512UnpackerForWidth<uint32_t, 16> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 64;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xffff;
@@ -1126,6 +1145,7 @@ struct Simd512UnpackerForWidth<uint32_t, 17> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 68;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1ffff;
@@ -1191,6 +1211,7 @@ struct Simd512UnpackerForWidth<uint32_t, 18> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 72;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3ffff;
@@ -1256,6 +1277,7 @@ struct Simd512UnpackerForWidth<uint32_t, 19> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 76;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7ffff;
@@ -1321,6 +1343,7 @@ struct Simd512UnpackerForWidth<uint32_t, 20> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 80;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xfffff;
@@ -1386,6 +1409,7 @@ struct Simd512UnpackerForWidth<uint32_t, 21> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 84;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1fffff;
@@ -1451,6 +1475,7 @@ struct Simd512UnpackerForWidth<uint32_t, 22> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 88;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3fffff;
@@ -1516,6 +1541,7 @@ struct Simd512UnpackerForWidth<uint32_t, 23> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 92;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7fffff;
@@ -1581,6 +1607,7 @@ struct Simd512UnpackerForWidth<uint32_t, 24> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 96;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xffffff;
@@ -1646,6 +1673,7 @@ struct Simd512UnpackerForWidth<uint32_t, 25> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 100;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1ffffff;
@@ -1711,6 +1739,7 @@ struct Simd512UnpackerForWidth<uint32_t, 26> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 104;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3ffffff;
@@ -1776,6 +1805,7 @@ struct Simd512UnpackerForWidth<uint32_t, 27> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 108;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7ffffff;
@@ -1841,6 +1871,7 @@ struct Simd512UnpackerForWidth<uint32_t, 28> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 112;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0xfffffff;
@@ -1906,6 +1937,7 @@ struct Simd512UnpackerForWidth<uint32_t, 29> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 116;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x1fffffff;
@@ -1971,6 +2003,7 @@ struct Simd512UnpackerForWidth<uint32_t, 30> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 120;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x3fffffff;
@@ -2036,6 +2069,7 @@ struct Simd512UnpackerForWidth<uint32_t, 31> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint32_t, 16>;
   static constexpr int kValuesUnpacked = 32;
+  static constexpr int kBytesRead = 124;
 
   static const uint8_t* unpack(const uint8_t* in, uint32_t* out) {
     constexpr uint32_t kMask = 0x7fffffff;
@@ -2102,6 +2136,7 @@ struct Simd512UnpackerForWidth<uint64_t, 1> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 8;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1;
@@ -2247,6 +2282,7 @@ struct Simd512UnpackerForWidth<uint64_t, 2> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 16;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3;
@@ -2392,6 +2428,7 @@ struct Simd512UnpackerForWidth<uint64_t, 3> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 24;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7;
@@ -2537,6 +2574,7 @@ struct Simd512UnpackerForWidth<uint64_t, 4> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 32;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xf;
@@ -2682,6 +2720,7 @@ struct Simd512UnpackerForWidth<uint64_t, 5> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 40;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1f;
@@ -2827,6 +2866,7 @@ struct Simd512UnpackerForWidth<uint64_t, 6> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 48;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3f;
@@ -2972,6 +3012,7 @@ struct Simd512UnpackerForWidth<uint64_t, 7> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 56;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7f;
@@ -3117,6 +3158,7 @@ struct Simd512UnpackerForWidth<uint64_t, 8> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 64;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xff;
@@ -3262,6 +3304,7 @@ struct Simd512UnpackerForWidth<uint64_t, 9> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 72;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ff;
@@ -3407,6 +3450,7 @@ struct Simd512UnpackerForWidth<uint64_t, 10> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 80;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ff;
@@ -3552,6 +3596,7 @@ struct Simd512UnpackerForWidth<uint64_t, 11> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 88;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ff;
@@ -3697,6 +3742,7 @@ struct Simd512UnpackerForWidth<uint64_t, 12> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 96;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfff;
@@ -3842,6 +3888,7 @@ struct Simd512UnpackerForWidth<uint64_t, 13> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 104;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fff;
@@ -3987,6 +4034,7 @@ struct Simd512UnpackerForWidth<uint64_t, 14> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 112;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fff;
@@ -4132,6 +4180,7 @@ struct Simd512UnpackerForWidth<uint64_t, 15> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 120;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fff;
@@ -4277,6 +4326,7 @@ struct Simd512UnpackerForWidth<uint64_t, 16> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 128;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffff;
@@ -4422,6 +4472,7 @@ struct Simd512UnpackerForWidth<uint64_t, 17> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 136;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffff;
@@ -4567,6 +4618,7 @@ struct Simd512UnpackerForWidth<uint64_t, 18> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 144;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffff;
@@ -4712,6 +4764,7 @@ struct Simd512UnpackerForWidth<uint64_t, 19> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 152;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffff;
@@ -4857,6 +4910,7 @@ struct Simd512UnpackerForWidth<uint64_t, 20> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 160;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffff;
@@ -5002,6 +5056,7 @@ struct Simd512UnpackerForWidth<uint64_t, 21> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 168;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffff;
@@ -5147,6 +5202,7 @@ struct Simd512UnpackerForWidth<uint64_t, 22> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 176;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffff;
@@ -5292,6 +5348,7 @@ struct Simd512UnpackerForWidth<uint64_t, 23> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 184;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffff;
@@ -5437,6 +5494,7 @@ struct Simd512UnpackerForWidth<uint64_t, 24> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 192;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffffff;
@@ -5582,6 +5640,7 @@ struct Simd512UnpackerForWidth<uint64_t, 25> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 200;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffffff;
@@ -5727,6 +5786,7 @@ struct Simd512UnpackerForWidth<uint64_t, 26> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 208;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffffff;
@@ -5872,6 +5932,7 @@ struct Simd512UnpackerForWidth<uint64_t, 27> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 216;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffffff;
@@ -6017,6 +6078,7 @@ struct Simd512UnpackerForWidth<uint64_t, 28> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 224;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffffff;
@@ -6162,6 +6224,7 @@ struct Simd512UnpackerForWidth<uint64_t, 29> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 232;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffffff;
@@ -6307,6 +6370,7 @@ struct Simd512UnpackerForWidth<uint64_t, 30> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 240;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffffff;
@@ -6452,6 +6516,7 @@ struct Simd512UnpackerForWidth<uint64_t, 31> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 248;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffffff;
@@ -6597,6 +6662,7 @@ struct Simd512UnpackerForWidth<uint64_t, 32> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 256;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffffffff;
@@ -6742,6 +6808,7 @@ struct Simd512UnpackerForWidth<uint64_t, 33> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 264;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffffffff;
@@ -6887,6 +6954,7 @@ struct Simd512UnpackerForWidth<uint64_t, 34> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 272;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffffffff;
@@ -7032,6 +7100,7 @@ struct Simd512UnpackerForWidth<uint64_t, 35> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 280;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffffffff;
@@ -7177,6 +7246,7 @@ struct Simd512UnpackerForWidth<uint64_t, 36> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 288;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffffffff;
@@ -7322,6 +7392,7 @@ struct Simd512UnpackerForWidth<uint64_t, 37> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 296;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffffffff;
@@ -7467,6 +7538,7 @@ struct Simd512UnpackerForWidth<uint64_t, 38> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 304;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffffffff;
@@ -7612,6 +7684,7 @@ struct Simd512UnpackerForWidth<uint64_t, 39> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 312;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffffffff;
@@ -7757,6 +7830,7 @@ struct Simd512UnpackerForWidth<uint64_t, 40> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 320;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffffffffff;
@@ -7902,6 +7976,7 @@ struct Simd512UnpackerForWidth<uint64_t, 41> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 328;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffffffffff;
@@ -8047,6 +8122,7 @@ struct Simd512UnpackerForWidth<uint64_t, 42> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 336;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffffffffff;
@@ -8192,6 +8268,7 @@ struct Simd512UnpackerForWidth<uint64_t, 43> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 344;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffffffffff;
@@ -8337,6 +8414,7 @@ struct Simd512UnpackerForWidth<uint64_t, 44> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 352;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffffffffff;
@@ -8482,6 +8560,7 @@ struct Simd512UnpackerForWidth<uint64_t, 45> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 360;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffffffffff;
@@ -8627,6 +8706,7 @@ struct Simd512UnpackerForWidth<uint64_t, 46> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 368;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffffffffff;
@@ -8772,6 +8852,7 @@ struct Simd512UnpackerForWidth<uint64_t, 47> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 376;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffffffffff;
@@ -8917,6 +8998,7 @@ struct Simd512UnpackerForWidth<uint64_t, 48> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 384;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffffffffffff;
@@ -9062,6 +9144,7 @@ struct Simd512UnpackerForWidth<uint64_t, 49> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 392;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffffffffffff;
@@ -9207,6 +9290,7 @@ struct Simd512UnpackerForWidth<uint64_t, 50> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 400;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffffffffffff;
@@ -9352,6 +9436,7 @@ struct Simd512UnpackerForWidth<uint64_t, 51> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 408;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffffffffffff;
@@ -9497,6 +9582,7 @@ struct Simd512UnpackerForWidth<uint64_t, 52> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 416;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffffffffffff;
@@ -9642,6 +9728,7 @@ struct Simd512UnpackerForWidth<uint64_t, 53> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 424;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffffffffffff;
@@ -9787,6 +9874,7 @@ struct Simd512UnpackerForWidth<uint64_t, 54> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 432;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffffffffffff;
@@ -9932,6 +10020,7 @@ struct Simd512UnpackerForWidth<uint64_t, 55> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 440;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffffffffffff;
@@ -10077,6 +10166,7 @@ struct Simd512UnpackerForWidth<uint64_t, 56> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 448;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xffffffffffffff;
@@ -10222,6 +10312,7 @@ struct Simd512UnpackerForWidth<uint64_t, 57> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 456;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1ffffffffffffff;
@@ -10367,6 +10458,7 @@ struct Simd512UnpackerForWidth<uint64_t, 58> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 464;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3ffffffffffffff;
@@ -10512,6 +10604,7 @@ struct Simd512UnpackerForWidth<uint64_t, 59> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 472;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7ffffffffffffff;
@@ -10657,6 +10750,7 @@ struct Simd512UnpackerForWidth<uint64_t, 60> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 480;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0xfffffffffffffff;
@@ -10802,6 +10896,7 @@ struct Simd512UnpackerForWidth<uint64_t, 61> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 488;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x1fffffffffffffff;
@@ -10947,6 +11042,7 @@ struct Simd512UnpackerForWidth<uint64_t, 62> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 496;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x3fffffffffffffff;
@@ -11092,6 +11188,7 @@ struct Simd512UnpackerForWidth<uint64_t, 63> {
 
   using simd_batch = xsimd::make_sized_batch_t<uint64_t, 8>;
   static constexpr int kValuesUnpacked = 64;
+  static constexpr int kBytesRead = 504;
 
   static const uint8_t* unpack(const uint8_t* in, uint64_t* out) {
     constexpr uint64_t kMask = 0x7fffffffffffffff;
diff --git a/cpp/src/arrow/util/bpacking_simd_avx2.cc b/cpp/src/arrow/util/bpacking_simd_avx2.cc
index 8261cdadf25..6db705eb99e 100644
--- a/cpp/src/arrow/util/bpacking_simd_avx2.cc
+++ b/cpp/src/arrow/util/bpacking_simd_avx2.cc
@@ -16,21 +16,24 @@
 // under the License.
 
 #include "arrow/util/bpacking_dispatch_internal.h"
-#include "arrow/util/bpacking_simd256_generated_internal.h"
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/bpacking_simd_internal.h"
+#include "arrow/util/bpacking_simd_kernel_internal.h"
 
 namespace arrow::internal {
 
+template <typename UnpackedUint, int kPackedBitSize>
+using Simd256Kernel = Kernel<UnpackedUint, kPackedBitSize, 256>;
+
 template <typename Uint>
-void unpack_avx2(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                 int bit_offset) {
-  return unpack_jump<Simd256UnpackerForWidth>(in, out, batch_size, num_bits, bit_offset);
+void unpack_avx2(const uint8_t* in, Uint* out, const UnpackOptions& opts) {
+  return unpack_jump<Simd256Kernel>(in, out, opts);
 }
 
-template void unpack_avx2<bool>(const uint8_t*, bool*, int, int, int);
-template void unpack_avx2<uint8_t>(const uint8_t*, uint8_t*, int, int, int);
-template void unpack_avx2<uint16_t>(const uint8_t*, uint16_t*, int, int, int);
-template void unpack_avx2<uint32_t>(const uint8_t*, uint32_t*, int, int, int);
-template void unpack_avx2<uint64_t>(const uint8_t*, uint64_t*, int, int, int);
+template void unpack_avx2<bool>(const uint8_t*, bool*, const UnpackOptions&);
+template void unpack_avx2<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&);
+template void unpack_avx2<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
+template void unpack_avx2<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
+template void unpack_avx2<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_simd_avx512.cc b/cpp/src/arrow/util/bpacking_simd_avx512.cc
index 76b102169ad..7ce21495a55 100644
--- a/cpp/src/arrow/util/bpacking_simd_avx512.cc
+++ b/cpp/src/arrow/util/bpacking_simd_avx512.cc
@@ -16,21 +16,21 @@
 // under the License.
 
 #include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/bpacking_simd512_generated_internal.h"
 #include "arrow/util/bpacking_simd_internal.h"
 
 namespace arrow::internal {
 
 template <typename Uint>
-void unpack_avx512(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                   int bit_offset) {
-  return unpack_jump<Simd512UnpackerForWidth>(in, out, batch_size, num_bits, bit_offset);
+void unpack_avx512(const uint8_t* in, Uint* out, const UnpackOptions& opts) {
+  return unpack_jump<Simd512UnpackerForWidth>(in, out, opts);
 }
 
-template void unpack_avx512<bool>(const uint8_t*, bool*, int, int, int);
-template void unpack_avx512<uint8_t>(const uint8_t*, uint8_t*, int, int, int);
-template void unpack_avx512<uint16_t>(const uint8_t*, uint16_t*, int, int, int);
-template void unpack_avx512<uint32_t>(const uint8_t*, uint32_t*, int, int, int);
-template void unpack_avx512<uint64_t>(const uint8_t*, uint64_t*, int, int, int);
+template void unpack_avx512<bool>(const uint8_t*, bool*, const UnpackOptions&);
+template void unpack_avx512<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&);
+template void unpack_avx512<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
+template void unpack_avx512<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
+template void unpack_avx512<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
 }  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_simd_codegen.py b/cpp/src/arrow/util/bpacking_simd_codegen.py
index 3218fe24cb6..df9b19bcf20 100755
--- a/cpp/src/arrow/util/bpacking_simd_codegen.py
+++ b/cpp/src/arrow/util/bpacking_simd_codegen.py
@@ -164,7 +164,9 @@ def print_struct_k(self, bit: int):
             "  using simd_batch = xsimd::make_sized_batch_t<"
             f"{self.out_type}, {self.simd_value_count}>;"
         )
-        print(f"  static constexpr int kValuesUnpacked = {self.out_bit_width};")
+        n_values_unpacked = self.out_bit_width # This is a property of this algorithm
+        print(f"  static constexpr int kValuesUnpacked = {n_values_unpacked};")
+        print(f"  static constexpr int kBytesRead = {(n_values_unpacked * bit) // 8};")
         print()
         self.print_unpack_bit_func(bit)
         print("};")
@@ -178,6 +180,10 @@ def print_uint32_fallback_struct(self):
             "  static constexpr int kValuesUnpacked = "
             f"{self.struct_name}<uint32_t, kBitWidth>::kValuesUnpacked;"
         )
+        print(
+            "  static constexpr int kBytesRead = "
+            f"{self.struct_name}<uint32_t, kBitWidth>::kBytesRead;"
+        )
         print()
 
         print(
diff --git a/cpp/src/arrow/util/bpacking_simd_default.cc b/cpp/src/arrow/util/bpacking_simd_default.cc
index e9af823807d..da3f8724b7d 100644
--- a/cpp/src/arrow/util/bpacking_simd_default.cc
+++ b/cpp/src/arrow/util/bpacking_simd_default.cc
@@ -15,28 +15,34 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/util/bpacking_dispatch_internal.h"
 #if defined(ARROW_HAVE_NEON)
-#  include "arrow/util/bpacking_simd128_generated_internal.h"
+#  define UNPACK_PLATFORM unpack_neon
+#elif defined(ARROW_HAVE_SSE4_2)
+#  define UNPACK_PLATFORM unpack_sse4_2
 #endif
-#include "arrow/util/bpacking_simd_internal.h"
+
+#if defined(UNPACK_PLATFORM)
+
+#  include "arrow/util/bpacking_dispatch_internal.h"
+#  include "arrow/util/bpacking_simd_internal.h"
+#  include "arrow/util/bpacking_simd_kernel_internal.h"
 
 namespace arrow::internal {
 
-#if defined(ARROW_HAVE_NEON)
+template <typename UnpackedUint, int kPackedBitSize>
+using Simd128Kernel = Kernel<UnpackedUint, kPackedBitSize, 128>;
 
 template <typename Uint>
-void unpack_neon(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                 int bit_offset) {
-  return unpack_jump<Simd128UnpackerForWidth>(in, out, batch_size, num_bits, bit_offset);
+void UNPACK_PLATFORM(const uint8_t* in, Uint* out, const UnpackOptions& opts) {
+  return unpack_jump<Simd128Kernel>(in, out, opts);
 }
 
-template void unpack_neon<bool>(const uint8_t*, bool*, int, int, int);
-template void unpack_neon<uint8_t>(const uint8_t*, uint8_t*, int, int, int);
-template void unpack_neon<uint16_t>(const uint8_t*, uint16_t*, int, int, int);
-template void unpack_neon<uint32_t>(const uint8_t*, uint32_t*, int, int, int);
-template void unpack_neon<uint64_t>(const uint8_t*, uint64_t*, int, int, int);
-
-#endif
+template void UNPACK_PLATFORM<bool>(const uint8_t*, bool*, const UnpackOptions&);
+template void UNPACK_PLATFORM<uint8_t>(const uint8_t*, uint8_t*, const UnpackOptions&);
+template void UNPACK_PLATFORM<uint16_t>(const uint8_t*, uint16_t*, const UnpackOptions&);
+template void UNPACK_PLATFORM<uint32_t>(const uint8_t*, uint32_t*, const UnpackOptions&);
+template void UNPACK_PLATFORM<uint64_t>(const uint8_t*, uint64_t*, const UnpackOptions&);
 
 }  // namespace arrow::internal
+
+#endif
diff --git a/cpp/src/arrow/util/bpacking_simd_internal.h b/cpp/src/arrow/util/bpacking_simd_internal.h
index 755b001140b..539617d39e8 100644
--- a/cpp/src/arrow/util/bpacking_simd_internal.h
+++ b/cpp/src/arrow/util/bpacking_simd_internal.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "arrow/util/bpacking_internal.h"
 #include "arrow/util/visibility.h"
 
 #include <cstdint>
@@ -26,73 +27,86 @@ namespace arrow::internal {
 #if defined(ARROW_HAVE_NEON)
 
 template <typename Uint>
-ARROW_EXPORT void unpack_neon(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                              int bit_offset);
+ARROW_EXPORT void unpack_neon(const uint8_t* in, Uint* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack_neon<bool>(const uint8_t* in, bool* out,
-                                                             int batch_size, int num_bits,
-                                                             int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack_neon<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_neon<uint8_t>(
-    const uint8_t* in, uint8_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_neon<uint16_t>(
-    const uint8_t* in, uint16_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_neon<uint32_t>(
-    const uint8_t* in, uint32_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_neon<uint64_t>(
-    const uint8_t* in, uint64_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
+
+#elif defined(ARROW_HAVE_SSE4_2)
+
+template <typename Uint>
+ARROW_EXPORT void unpack_sse4_2(const uint8_t* in, Uint* out, const UnpackOptions& opts);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_sse4_2<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_sse4_2<uint8_t>(
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_sse4_2<uint16_t>(
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_sse4_2<uint32_t>(
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
+
+extern template ARROW_TEMPLATE_EXPORT void unpack_sse4_2<uint64_t>(
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
 #endif
 
 #if defined(ARROW_HAVE_AVX2) || defined(ARROW_HAVE_RUNTIME_AVX2)
 
 template <typename Uint>
-ARROW_EXPORT void unpack_avx2(const uint8_t* in, Uint* out, int batch_size, int num_bits,
-                              int bit_offset);
+ARROW_EXPORT void unpack_avx2(const uint8_t* in, Uint* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<bool>(const uint8_t* in, bool* out,
-                                                             int batch_size, int num_bits,
-                                                             int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<uint8_t>(
-    const uint8_t* in, uint8_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<uint16_t>(
-    const uint8_t* in, uint16_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<uint32_t>(
-    const uint8_t* in, uint32_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx2<uint64_t>(
-    const uint8_t* in, uint64_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
 #endif
 
 #if defined(ARROW_HAVE_AVX512) || defined(ARROW_HAVE_RUNTIME_AVX512)
 
 template <typename Uint>
-ARROW_EXPORT void unpack_avx512(const uint8_t* in, Uint* out, int batch_size,
-                                int num_bits, int bit_offset);
+ARROW_EXPORT void unpack_avx512(const uint8_t* in, Uint* out, const UnpackOptions& opts);
 
-extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<bool>(const uint8_t* in,
-                                                               bool* out, int batch_size,
-                                                               int num_bits,
-                                                               int bit_offset);
+extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<bool>(  //
+    const uint8_t* in, bool* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint8_t>(
-    const uint8_t* in, uint8_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint8_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint16_t>(
-    const uint8_t* in, uint16_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint16_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint32_t>(
-    const uint8_t* in, uint32_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint32_t* out, const UnpackOptions& opts);
 
 extern template ARROW_TEMPLATE_EXPORT void unpack_avx512<uint64_t>(
-    const uint8_t* in, uint64_t* out, int batch_size, int num_bits, int bit_offset);
+    const uint8_t* in, uint64_t* out, const UnpackOptions& opts);
 
 #endif
 
diff --git a/cpp/src/arrow/util/bpacking_simd_kernel_internal.h b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
new file mode 100644
index 00000000000..23b4ccb3202
--- /dev/null
+++ b/cpp/src/arrow/util/bpacking_simd_kernel_internal.h
@@ -0,0 +1,886 @@
+// 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.
+
+/// Simd integer unpacking kernels, that is small functions that efficiently operate over
+/// a fixed input size.
+///
+/// This a generalization of the algorithm from Daniel Lemire and Leonid Boytsov,
+/// Decoding billions of integers per second through vectorization, Software Practice &
+/// Experience 45 (1), 2015.
+/// http://arxiv.org/abs/1209.2137
+/// https://github.com/fast-pack/LittleIntPacker/blob/master/src/horizontalpacking32.c
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <numeric>
+#include <utility>
+
+#include <xsimd/xsimd.hpp>
+
+#include "arrow/util/bit_util.h"
+#include "arrow/util/bpacking_dispatch_internal.h"
+#include "arrow/util/type_traits.h"
+
+namespace arrow::internal {
+
+/*********************
+ *  xsimd utilities  *
+ *********************/
+
+/// Simple constexpr maximum element suited for non empty arrays.
+template <typename T, std::size_t N>
+constexpr T max_value(const std::array<T, N>& arr) {
+  static_assert(N > 0);
+  T out = 0;
+  for (const T& v : arr) {
+    if (v > out) {
+      out = v;
+    }
+  }
+  return out;
+}
+
+template <std::array kArr, typename Arch, std::size_t... Is>
+constexpr auto array_to_batch_constant_impl(std::index_sequence<Is...>) {
+  using Array = std::decay_t<decltype(kArr)>;
+  using value_type = typename Array::value_type;
+
+  return xsimd::batch_constant<value_type, Arch, kArr[Is]...>{};
+}
+
+/// Make a ``xsimd::batch_constant`` from a static constexpr array.
+template <std::array kArr, typename Arch>
+constexpr auto array_to_batch_constant() {
+  return array_to_batch_constant_impl<kArr, Arch>(
+      std::make_index_sequence<kArr.size()>());
+}
+
+template <typename T, std::size_t N>
+struct SwizzleBiLaneGenericPlan {
+  using ByteSwizzle = std::array<T, N>;
+
+  ByteSwizzle self_lane;
+  ByteSwizzle cross_lane;
+};
+
+template <typename T, std::size_t N>
+constexpr SwizzleBiLaneGenericPlan<T, N> BuildSwizzleBiLaneGenericPlan(
+    std::array<T, N> mask) {
+  constexpr T kAsZero = 0x80;  // Most significant bit of the byte must be 1
+  constexpr std::size_t kSize = N;
+  constexpr std::size_t kSizeHalf = kSize / 2;
+
+  SwizzleBiLaneGenericPlan<T, N> plan = {};
+
+  for (std::size_t k = 0; k < kSize; ++k) {
+    const bool is_defined = (0 <= mask[k]) && (mask[k] < kSize);
+    const bool is_first_lane_idx = k < kSizeHalf;
+    const bool is_first_lane_mask = mask[k] < kSizeHalf;
+
+    if (!is_defined) {
+      plan.self_lane[k] = kAsZero;
+      plan.cross_lane[k] = kAsZero;
+    } else {
+      if (is_first_lane_idx == is_first_lane_mask) {
+        plan.self_lane[k] = mask[k] % kSizeHalf;
+        plan.cross_lane[k] = kAsZero;
+      } else {
+        plan.self_lane[k] = kAsZero;
+        plan.cross_lane[k] = mask[k] % kSizeHalf;
+      }
+    }
+  }
+
+  return plan;
+}
+
+template <typename T, typename A, T... Vals>
+constexpr bool isOnlyFromHigh(xsimd::batch_constant<T, A, Vals...>) {
+  return ((Vals >= (sizeof...(Vals) / 2)) && ...);
+}
+
+template <typename T, typename A, T... Vals>
+constexpr bool isOnlyFromLow(xsimd::batch_constant<T, A, Vals...>) {
+  return ((Vals < (sizeof...(Vals) / 2)) && ...);
+}
+
+/// Wrapper around ``xsimd::swizzle`` with optimizations and non implemented sizes.
+/// TODO(xsimd 14.0) Merged and can be replaced with ``xsimd::swizzle``.
+template <typename Arch, uint8_t... kIdx>
+auto swizzle_bytes(const xsimd::batch<uint8_t, Arch>& batch,
+                   xsimd::batch_constant<uint8_t, Arch, kIdx...> mask)
+    -> xsimd::batch<uint8_t, Arch> {
+  if constexpr (std::is_base_of_v<xsimd::avx2, Arch>) {
+    constexpr auto kPlan = BuildSwizzleBiLaneGenericPlan(std::array{kIdx...});
+    constexpr auto kSelfSwizzle = array_to_batch_constant<kPlan.self_lane, Arch>();
+    constexpr auto kCrossSwizzle = array_to_batch_constant<kPlan.cross_lane, Arch>();
+
+    constexpr auto kLaneMaskArr =
+        std::array{static_cast<uint8_t>(kIdx % (mask.size / 2))...};
+    constexpr auto kLaneMask = array_to_batch_constant<kLaneMaskArr, Arch>();
+
+    if constexpr (isOnlyFromLow(mask)) {
+      auto broadcast = _mm256_permute2x128_si256(batch, batch, 0x00);  // [low | low]
+      return _mm256_shuffle_epi8(broadcast, kLaneMask.as_batch());
+    }
+    if constexpr (isOnlyFromHigh(mask)) {
+      auto broadcast = _mm256_permute2x128_si256(batch, batch, 0x11);  // [high | high]
+      return _mm256_shuffle_epi8(broadcast, kLaneMask.as_batch());
+    }
+
+    auto self = _mm256_shuffle_epi8(batch, kSelfSwizzle.as_batch());
+    auto swapped = _mm256_permute2x128_si256(batch, batch, 0x01);
+    auto cross = _mm256_shuffle_epi8(swapped, kCrossSwizzle.as_batch());
+    return _mm256_or_si256(self, cross);
+  } else {
+    return xsimd::swizzle(batch, mask);
+  }
+}
+
+template <typename Int, typename Arch, Int... kShifts>
+constexpr auto make_mult(xsimd::batch_constant<Int, Arch, kShifts...>) {
+  return xsimd::batch_constant<Int, Arch, static_cast<Int>(1u << kShifts)...>();
+}
+
+template <typename Int, int kOffset, int kLength, typename Arr>
+constexpr auto select_stride_impl(Arr shifts) {
+  std::array<Int, shifts.size() / kLength> out{};
+  for (std::size_t i = 0; i < out.size(); ++i) {
+    out[i] = shifts[kLength * i + kOffset];
+  }
+  return out;
+}
+
+template <typename ToInt, int kOffset, typename Int, typename Arch, Int... kShifts>
+constexpr auto select_stride(xsimd::batch_constant<Int, Arch, kShifts...>) {
+  constexpr auto kStridesArr =
+      select_stride_impl<ToInt, kOffset, sizeof(ToInt) / sizeof(Int)>(
+          std::array{kShifts...});
+  return array_to_batch_constant<kStridesArr, Arch>();
+}
+
+template <typename Arch>
+constexpr bool HasSse2 = std::is_base_of_v<xsimd::sse2, Arch>;
+
+template <typename Arch>
+constexpr bool HasAvx2 = std::is_base_of_v<xsimd::avx2, Arch>;
+
+/// Wrapper around ``xsimd::bitwise_lshift`` with optimizations for non implemented sizes.
+//
+// We replace the variable left shift by a variable multiply with a power of two.
+//
+// This trick is borrowed from Daniel Lemire and Leonid Boytsov, Decoding billions of
+// integers per second through vectorization, Software Practice & Experience 45 (1), 2015.
+// http://arxiv.org/abs/1209.2137
+//
+/// TODO(xsimd) Tracking in https://github.com/xtensor-stack/xsimd/pull/1220
+template <typename Arch, typename Int, Int... kShifts>
+auto left_shift(const xsimd::batch<Int, Arch>& batch,
+                xsimd::batch_constant<Int, Arch, kShifts...> shifts)
+    -> xsimd::batch<Int, Arch> {
+  constexpr bool kHasSse2 = HasSse2<Arch>;
+  constexpr bool kHasAvx2 = HasAvx2<Arch>;
+  static_assert(!(kHasSse2 && kHasAvx2), "The hierarchy are different in xsimd");
+
+  // TODO(xsimd-14) this can be simplified to
+  // constexpr auto kMults = xsimd::make_batch_constant<Int, 1, Arch>() << shits;
+  constexpr auto kMults = make_mult(shifts);
+
+  constexpr auto IntSize = sizeof(Int);
+
+  // Sizes and architecture for which there is no variable left shift and there is a
+  // multiplication
+  if constexpr (                                                                  //
+      (kHasSse2 && (IntSize == sizeof(uint16_t) || IntSize == sizeof(uint32_t)))  //
+      || (kHasAvx2 && (IntSize == sizeof(uint16_t)))                              //
+  ) {
+    return batch * kMults;
+  }
+
+  // Architecture for which there is no variable left shift on uint8_t but a fallback
+  // exists for uint16_t.
+  if constexpr ((kHasSse2 || kHasAvx2) && (IntSize == sizeof(uint8_t))) {
+    const auto batch16 = xsimd::bitwise_cast<uint16_t>(batch);
+
+    constexpr auto kShifts0 = select_stride<uint16_t, 0>(shifts);
+    const auto shifted0 = left_shift(batch16, kShifts0) & 0x00FF;
+
+    constexpr auto kShifts1 = select_stride<uint16_t, 1>(shifts);
+    const auto shifted1 = left_shift(batch16 & 0xFF00, kShifts1);
+
+    return xsimd::bitwise_cast<Int>(shifted0 | shifted1);
+  }
+
+  return batch << shifts;
+}
+
+/// Fallback for variable shift right.
+///
+/// When we know that the relevant bits will not overflow, we can instead shift left all
+/// values to align them with the one with the largest right shifts followed by a constant
+/// shift on all values.
+/// In doing so, we replace the variable left shift by a variable multiply with a power of
+/// two.
+///
+/// This trick is borrowed from Daniel Lemire and Leonid Boytsov, Decoding billions of
+/// integers per second through vectorization, Software Practice & Experience 45 (1),
+/// 2015. http://arxiv.org/abs/1209.2137
+template <typename Arch, typename Int, Int... kShifts>
+auto right_shift_by_excess(const xsimd::batch<Int, Arch>& batch,
+                           xsimd::batch_constant<Int, Arch, kShifts...> shifts) {
+  constexpr bool kHasSse2 = HasSse2<Arch>;
+  constexpr bool kHasAvx2 = HasAvx2<Arch>;
+  static_assert(!(kHasSse2 && kHasAvx2), "The hierarchy are different in xsimd");
+
+  constexpr auto IntSize = sizeof(Int);
+
+  // Architecture for which there is no variable right shift but a larger fallback exists.
+  /// TODO(xsimd) Tracking for Avx2 in https://github.com/xtensor-stack/xsimd/pull/1220
+  if constexpr (kHasAvx2 && (IntSize == sizeof(uint8_t) || IntSize == sizeof(uint16_t))) {
+    using twice_uint = SizedUint<2 * IntSize>;
+
+    const auto batch2 = xsimd::bitwise_cast<twice_uint>(batch);
+
+    constexpr auto kShifts0 = select_stride<twice_uint, 0>(shifts);
+    constexpr auto kMask0 = bit_util::LeastSignificantBitMask<twice_uint>(8 * IntSize);
+    const auto shifted0 = right_shift_by_excess(batch2 & kMask0, kShifts0);
+
+    constexpr auto kShifts1 = select_stride<twice_uint, 1>(shifts);
+    constexpr auto kMask1 = kMask0 << (8 * IntSize);
+    const auto shifted1 = right_shift_by_excess(batch2, kShifts1) & kMask1;
+
+    return xsimd::bitwise_cast<Int>(shifted0 | shifted1);
+  }
+
+  // These conditions are the ones matched in `left_shift`, i.e. the ones where variable
+  // shift right will not be available but a left shift (fallback) exists.
+  if constexpr (kHasSse2 && (IntSize != sizeof(uint64_t))) {
+    constexpr auto kShiftsArr = std::array{kShifts...};
+    constexpr Int kMaxRightShift = max_value(kShiftsArr);
+    constexpr auto kLShiftsArr =
+        std::array{static_cast<Int>(kMaxRightShift - kShifts)...};
+
+    // TODO(xsimd 14.0) this can be simplified to
+    // constexpr auto kRShifts = xsimd::make_batch_constant<Int, kMaxRightShift, Arch>() -
+    // shifts;
+    constexpr auto kLShifts = array_to_batch_constant<kLShiftsArr, Arch>();
+
+    const auto lshifted = left_shift(batch, kLShifts);
+    // TODO(xsimd 14.0) this can be simplified to
+    // return xsimd::bitwise_rshift<kMaxRightShift>(lshifted);
+    return xsimd::batch<Int, Arch>(lshifted) >> kMaxRightShift;
+  }
+
+  return batch >> shifts;
+}
+
+/****************************
+ *  Properties of a kernel  *
+ ****************************/
+
+/// \see KernelShape
+constexpr bool PackedIsOversizedForSimd(int simd_bit_size, int unpacked_bit_size,
+                                        int packed_bit_size) {
+  const int unpacked_per_simd = simd_bit_size / unpacked_bit_size;
+
+  const auto packed_per_read_for_offset = [&](int bit_offset) -> int {
+    return (simd_bit_size - bit_offset) / packed_bit_size;
+  };
+
+  int packed_start_bit = 0;
+  do {
+    int packed_per_read = packed_per_read_for_offset(packed_start_bit % 8);
+    if (packed_per_read < unpacked_per_simd) {
+      return true;
+    }
+    packed_start_bit += unpacked_per_simd * packed_bit_size;
+  } while (packed_start_bit % 8 != 0);
+
+  return false;
+}
+
+/// Different sizes of a given kernel.
+///
+/// When integers are bit-packed, they spread over multiple bytes.
+/// For instance, integers packed voer three bits quickly spread over two bytes (on the
+/// value `C` below) despite three bits being much smaller than a single byte.
+///
+/// ```
+/// |A|A|A|B|B|B|C|C|  |C|D|D|D|E|E|E|F| ...
+/// ```
+///
+/// When the spread is smaller or equal to the unsigned integer to unpack to, we classify
+/// if as "medium". When it is strictly larger it classifies as "large".
+/// On rare occasions, due to offsets in reading a subsequent batch, we may not even be
+/// able to read as many packed values as we should extract in a batch (mainly unpack 63
+/// bits to uint64_t on 128 bit SIMD). We classify this as "oversized".
+struct KernelShape {
+  const int simd_bit_size_;
+  const int unpacked_bit_size_;
+  const int packed_bit_size_;
+  const int packed_max_spread_bytes_ = PackedMaxSpreadBytes(packed_bit_size_, 0);
+  const bool is_oversized_ =
+      PackedIsOversizedForSimd(simd_bit_size_, unpacked_bit_size_, packed_bit_size_);
+
+  constexpr bool is_medium() const {
+    return packed_max_spread_bytes() <= unpacked_byte_size();
+  }
+  constexpr bool is_large() const { return !is_medium() && !is_oversized(); }
+  constexpr bool is_oversized() const { return is_oversized_; }
+
+  /// Properties of an SIMD batch
+  constexpr int simd_bit_size() const { return simd_bit_size_; }
+  constexpr int simd_byte_size() const { return simd_bit_size_ / 8; }
+
+  /// Properties of the unpacked integers
+  constexpr int unpacked_bit_size() const { return unpacked_bit_size_; }
+  constexpr int unpacked_byte_size() const { return unpacked_bit_size_ / 8; }
+  constexpr int unpacked_per_simd() const { return simd_bit_size_ / unpacked_bit_size_; }
+
+  /// Properties of the packed integers
+  constexpr int packed_bit_size() const { return packed_bit_size_; }
+  constexpr int packed_max_spread_bytes() const { return packed_max_spread_bytes_; }
+};
+
+/// Packing all useful and derived information about a kernel in a single type.
+template <typename UnpackedUint, int kPackedBitSize, int kSimdBitSize>
+struct KernelTraits {
+  static constexpr KernelShape kShape = {
+      .simd_bit_size_ = kSimdBitSize,
+      .unpacked_bit_size_ = 8 * sizeof(UnpackedUint),
+      .packed_bit_size_ = kPackedBitSize,
+  };
+
+  using unpacked_type = UnpackedUint;
+  // The integer type to work with, `unpacked_type` or an appropriate type for bool.
+  using uint_type = std::conditional_t<std::is_same_v<unpacked_type, bool>,
+                                       SizedUint<sizeof(bool)>, unpacked_type>;
+  using simd_batch = xsimd::make_sized_batch_t<uint_type, kShape.unpacked_per_simd()>;
+  using simd_bytes = xsimd::make_sized_batch_t<uint8_t, kShape.simd_byte_size()>;
+  using arch_type = typename simd_batch::arch_type;
+};
+
+template <typename Traits, typename Uint>
+using KernelTraitsWithUnpack =
+    KernelTraits<Uint, Traits::kShape.packed_bit_size(), Traits::kShape.simd_bit_size()>;
+
+/******************
+ *  MediumKernel  *
+ ******************/
+
+struct MediumKernelPlanSize {
+  int reads_per_kernel_;
+  int swizzles_per_read_;
+  int shifts_per_swizzle_;
+
+  constexpr int reads_per_kernel() const { return reads_per_kernel_; }
+
+  constexpr int swizzles_per_read() const { return swizzles_per_read_; }
+  constexpr int swizzles_per_kernel() const {
+    return swizzles_per_read_ * reads_per_kernel();
+  }
+
+  constexpr int shifts_per_swizzle() const { return shifts_per_swizzle_; }
+  constexpr int shifts_per_read() const {
+    return shifts_per_swizzle_ * swizzles_per_read();
+  }
+  constexpr int shifts_per_kernel() const {
+    return shifts_per_read() * reads_per_kernel();
+  }
+};
+
+template <int kUnpackedPerKernelLimit_>
+struct MediumKernelOptions {
+  /// An indicative limit on the number of values unpacked by the kernel.
+  /// This is a heuristic setting: other constraints such as alignment may not always make
+  /// small values feasibles. Must be a power of two.
+  static constexpr int kUnpackedPerKernelLimit = kUnpackedPerKernelLimit_;
+};
+
+template <typename KernelOptions>
+constexpr MediumKernelPlanSize BuildMediumPlanSize(const KernelShape& shape) {
+  const int shifts_per_swizzle =
+      shape.unpacked_byte_size() / shape.packed_max_spread_bytes();
+
+  const int vals_per_swizzle = shifts_per_swizzle * shape.unpacked_per_simd();
+
+  // Using `unpacked_per_kernel_limit` to influence the number of swizzles per reads.
+  const auto packed_per_read_for_offset = [&](int bit_offset) -> int {
+    const int best = (shape.simd_bit_size() - bit_offset) / shape.packed_bit_size();
+    const int limit = KernelOptions::kUnpackedPerKernelLimit;
+    return (best > limit) && (limit > 0) ? limit : best;
+  };
+
+  const auto swizzles_per_read_for_offset = [&](int bit_offset) -> int {
+    return packed_per_read_for_offset(bit_offset) / vals_per_swizzle;
+  };
+
+  // If after a whole swizzle reading iteration we fall unaligned, the remaining
+  // iterations will start with an unaligned first value, reducing the effective capacity
+  // of the SIMD batch.
+  // We must check that our read iteration size still works with subsequent misalignment
+  // by looping until aligned.
+  // One may think that using such large reading iterations risks overshooting an aligned
+  // byte and increasing the total number of values extracted, but in practice reading
+  // iterations increase by factors of 2 and are quickly multiple of 8 (and aligned after
+  // the first one).
+  int swizzles_per_read = swizzles_per_read_for_offset(0);
+  int reads_per_kernel = 0;
+  int packed_start_bit = 0;
+  do {
+    int new_swizzles_per_read = swizzles_per_read_for_offset(packed_start_bit % 8);
+    if (new_swizzles_per_read < swizzles_per_read) {
+      swizzles_per_read = new_swizzles_per_read;
+      packed_start_bit = 0;
+      reads_per_kernel = 0;
+    }
+    int bits_per_read = swizzles_per_read * vals_per_swizzle * shape.packed_bit_size();
+    packed_start_bit += bits_per_read;
+    reads_per_kernel += 1;
+  } while (packed_start_bit % 8 != 0);
+
+  return {
+      .reads_per_kernel_ = reads_per_kernel,
+      .swizzles_per_read_ = swizzles_per_read,
+      .shifts_per_swizzle_ = shifts_per_swizzle,
+  };
+}
+
+constexpr int reduced_bytes_per_read(int bits_per_read, int simd_byte_size) {
+  if (bits_per_read <= static_cast<int>(8 * sizeof(uint32_t))) {
+    return sizeof(uint32_t);
+  } else if (bits_per_read <= static_cast<int>(8 * sizeof(uint64_t))) {
+    return sizeof(uint64_t);
+  }
+  return simd_byte_size;
+}
+
+template <typename KernelTraits, typename KernelOptions>
+struct MediumKernelPlan {
+  using Traits = KernelTraits;
+  using uint_type = typename Traits::uint_type;
+  static constexpr auto kShape = Traits::kShape;
+  static constexpr auto kPlanSize = BuildMediumPlanSize<KernelOptions>(kShape);
+
+  using ReadsPerKernel = std::array<int, kPlanSize.reads_per_kernel()>;
+
+  using Swizzle = std::array<uint8_t, kShape.simd_byte_size()>;
+  using SwizzlesPerRead = std::array<Swizzle, kPlanSize.swizzles_per_read()>;
+  using SwizzlesPerKernel = std::array<SwizzlesPerRead, kPlanSize.reads_per_kernel()>;
+
+  using Shift = std::array<uint_type, kShape.unpacked_per_simd()>;
+  using ShiftsPerSwizzle = std::array<Shift, kPlanSize.shifts_per_swizzle()>;
+  using ShiftsPerRead = std::array<ShiftsPerSwizzle, kPlanSize.swizzles_per_read()>;
+  using ShitsPerKernel = std::array<ShiftsPerRead, kPlanSize.reads_per_kernel()>;
+
+  static constexpr int unpacked_per_shifts() { return kShape.unpacked_per_simd(); }
+  static constexpr int unpacked_per_swizzle() {
+    return unpacked_per_shifts() * kPlanSize.shifts_per_swizzle();
+  }
+  static constexpr int unpacked_per_read() {
+    return unpacked_per_swizzle() * kPlanSize.swizzles_per_read();
+  }
+  static constexpr int unpacked_per_kernel() {
+    return unpacked_per_read() * kPlanSize.reads_per_kernel();
+  }
+
+  static constexpr int bytes_per_read() {
+    const auto bits_per_read = unpacked_per_read() * kShape.packed_bit_size();
+    return reduced_bytes_per_read(bits_per_read, kShape.simd_byte_size());
+  }
+
+  constexpr int total_bytes_read() const { return reads.back() + bytes_per_read(); }
+
+  ReadsPerKernel reads;
+  SwizzlesPerKernel swizzles;
+  ShitsPerKernel shifts;
+  uint_type mask = bit_util::LeastSignificantBitMask<uint_type>(kShape.packed_bit_size());
+};
+
+template <typename Arr>
+constexpr Arr BuildConstantArray(typename Arr::value_type val) {
+  Arr out = {};
+  for (auto& v : out) {
+    v = val;
+  }
+  return out;
+}
+
+template <typename KernelTraits, typename KernelOptions>
+constexpr auto BuildMediumPlan() {
+  using Plan = MediumKernelPlan<KernelTraits, KernelOptions>;
+  constexpr auto kShape = Plan::kShape;
+  constexpr auto kPlanSize = Plan::kPlanSize;
+  static_assert(kShape.is_medium());
+
+  Plan plan = {};
+
+  int packed_start_bit = 0;
+  for (int r = 0; r < kPlanSize.reads_per_kernel(); ++r) {
+    const int read_start_byte = packed_start_bit / 8;
+    plan.reads.at(r) = read_start_byte;
+
+    for (int sw = 0; sw < kPlanSize.swizzles_per_read(); ++sw) {
+      constexpr int kUndefined = -1;
+      plan.swizzles.at(r).at(sw) = BuildConstantArray<typename Plan::Swizzle>(kUndefined);
+      for (int sh = 0; sh < kPlanSize.shifts_per_swizzle(); ++sh) {
+        const int sh_offset_bytes = sh * kShape.packed_max_spread_bytes();
+        const int sh_offset_bits = 8 * sh_offset_bytes;
+
+        for (int u = 0; u < kShape.unpacked_per_simd(); ++u) {
+          const int packed_start_byte = packed_start_bit / 8;
+          const int packed_byte_in_read = packed_start_byte - read_start_byte;
+          const int u_offset_byte = u * kShape.unpacked_byte_size();
+          const int sw_offset_byte = sh_offset_bytes + u_offset_byte;
+
+          // Looping over the multiple bytes needed for current values
+          for (int b = 0; b < kShape.packed_max_spread_bytes(); ++b) {
+            plan.swizzles.at(r).at(sw).at(sw_offset_byte + b) =
+                static_cast<uint8_t>(packed_byte_in_read + b);
+          }
+          // Shift is a single value but many packed values may be swizzles to a sing
+          // unpacked value
+          plan.shifts.at(r).at(sw).at(sh).at(u) = sh_offset_bits + packed_start_bit % 8;
+
+          packed_start_bit += kShape.packed_bit_size();
+        }
+      }
+    }
+  }
+
+  return plan;
+}
+
+template <typename Uint, typename Arch>
+xsimd::batch<uint8_t, Arch> load_bytes_as(const uint8_t* in) {
+  const Uint val = util::SafeLoadAs<Uint>(in);
+  const auto batch = xsimd::batch<Uint, Arch>(val);
+  return xsimd::bitwise_cast<uint8_t>(batch);
+}
+
+template <int kBytes, typename Arch>
+xsimd::batch<uint8_t, Arch> load_bytes(const uint8_t* in) {
+  if constexpr (kBytes <= sizeof(uint64_t)) {
+    return load_bytes_as<SizedUint<kBytes>, Arch>(in);
+  }
+  using simd_bytes = xsimd::batch<uint8_t, Arch>;
+  return simd_bytes::load_unaligned(in);
+}
+
+template <typename KernelTraits, typename KernelOptions = MediumKernelOptions<32>>
+struct MediumKernel {
+  static constexpr auto kPlan = BuildMediumPlan<KernelTraits, KernelOptions>();
+  static constexpr auto kPlanSize = kPlan.kPlanSize;
+  static constexpr auto kShape = kPlan.kShape;
+  using Traits = typename decltype(kPlan)::Traits;
+  using unpacked_type = typename Traits::unpacked_type;
+  using uint_type = typename Traits::uint_type;
+  using simd_batch = typename Traits::simd_batch;
+  using simd_bytes = typename Traits::simd_bytes;
+  using arch_type = typename Traits::arch_type;
+
+  static constexpr int kValuesUnpacked = kPlan.unpacked_per_kernel();
+  static constexpr int kBytesRead = kPlan.total_bytes_read();
+
+  template <int kReadIdx, int kSwizzleIdx, int kShiftIdx>
+  static void unpack_one_shift_impl(const simd_batch& words, unpacked_type* out) {
+    constexpr auto kRightShiftsArr =
+        kPlan.shifts.at(kReadIdx).at(kSwizzleIdx).at(kShiftIdx);
+    constexpr auto kRightShifts = array_to_batch_constant<kRightShiftsArr, arch_type>();
+    constexpr auto kMask = kPlan.mask;
+    constexpr auto kOutOffset = (kReadIdx * kPlan.unpacked_per_read() +
+                                 kSwizzleIdx * kPlan.unpacked_per_swizzle() +
+                                 kShiftIdx * kPlan.unpacked_per_shifts());
+
+    // Intel x86-64 does not have variable right shifts before AVX2.
+    // We know the packed value can safely be left shifted up to the largest offset so we
+    // can use the fallback on these platforms.
+    const auto shifted = right_shift_by_excess(words, kRightShifts);
+    const auto vals = shifted & kMask;
+    if constexpr (std::is_same_v<unpacked_type, bool>) {
+      const xsimd::batch_bool<uint_type, arch_type> bools = vals != 0;
+      bools.store_unaligned(out + kOutOffset);
+    } else {
+      vals.store_unaligned(out + kOutOffset);
+    }
+  }
+
+  template <int kReadIdx, int kSwizzleIdx, int... kShiftIds>
+  static void unpack_one_swizzle_impl(const simd_bytes& bytes, unpacked_type* out,
+                                      std::integer_sequence<int, kShiftIds...>) {
+    constexpr auto kSwizzlesArr = kPlan.swizzles.at(kReadIdx).at(kSwizzleIdx);
+    constexpr auto kSwizzles = array_to_batch_constant<kSwizzlesArr, arch_type>();
+
+    const auto swizzled = swizzle_bytes(bytes, kSwizzles);
+    const auto words = xsimd::bitwise_cast<uint_type>(swizzled);
+    (unpack_one_shift_impl<kReadIdx, kSwizzleIdx, kShiftIds>(words, out), ...);
+  }
+
+  template <int kReadIdx, int... kSwizzleIds>
+  static void unpack_one_read_impl(const uint8_t* in, unpacked_type* out,
+                                   std::integer_sequence<int, kSwizzleIds...>) {
+    using ShiftSeq = std::make_integer_sequence<int, kPlanSize.shifts_per_swizzle()>;
+    const auto bytes =
+        load_bytes<kPlan.bytes_per_read(), arch_type>(in + kPlan.reads.at(kReadIdx));
+    (unpack_one_swizzle_impl<kReadIdx, kSwizzleIds>(bytes, out, ShiftSeq{}), ...);
+  }
+
+  template <int... kReadIds>
+  static void unpack_all_impl(const uint8_t* in, unpacked_type* out,
+                              std::integer_sequence<int, kReadIds...>) {
+    using SwizzleSeq = std::make_integer_sequence<int, kPlanSize.swizzles_per_read()>;
+    (unpack_one_read_impl<kReadIds>(in, out, SwizzleSeq{}), ...);
+  }
+
+  static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
+    using ReadSeq = std::make_integer_sequence<int, kPlanSize.reads_per_kernel()>;
+    unpack_all_impl(in, out, ReadSeq{});
+    return in + (kPlan.unpacked_per_kernel() * kShape.packed_bit_size()) / 8;
+  }
+};
+
+/*****************
+ *  LargeKernel  *
+ *****************/
+
+template <typename KernelTraits>
+struct LargeKernelPlan {
+  using Traits = KernelTraits;
+  using uint_type = typename Traits::uint_type;
+  static constexpr auto kShape = Traits::kShape;
+
+  static constexpr int kUnpackedPerkernel = std::lcm(kShape.unpacked_per_simd(), 8);
+  static constexpr int kReadsPerKernel = static_cast<int>(bit_util::CeilDiv(
+      kUnpackedPerkernel * kShape.packed_bit_size(), kShape.simd_bit_size()));
+  static constexpr int kUnpackedPerRead = kUnpackedPerkernel / kReadsPerKernel;
+
+  using ReadsPerKernel = std::array<int, kReadsPerKernel>;
+
+  using Swizzle = std::array<uint8_t, kShape.simd_byte_size()>;
+  using SwizzlesPerKernel = std::array<Swizzle, kReadsPerKernel>;
+
+  using Shift = std::array<uint_type, kShape.unpacked_per_simd()>;
+  using ShitsPerKernel = std::array<Shift, kReadsPerKernel>;
+
+  static constexpr int bytes_per_read() {
+    const auto bits_per_read = kUnpackedPerRead * kShape.packed_bit_size();
+    return reduced_bytes_per_read(bits_per_read, kShape.simd_byte_size());
+  }
+
+  constexpr int total_bytes_read() const { return reads.back() + bytes_per_read(); }
+
+  ReadsPerKernel reads;
+  SwizzlesPerKernel low_swizzles;
+  SwizzlesPerKernel high_swizzles;
+  ShitsPerKernel low_rshifts;
+  ShitsPerKernel high_lshifts;
+  uint_type mask;
+};
+
+template <typename KernelTraits>
+constexpr LargeKernelPlan<KernelTraits> BuildLargePlan() {
+  using Plan = LargeKernelPlan<KernelTraits>;
+  using uint_type = typename Plan::Traits::uint_type;
+  constexpr auto kShape = Plan::kShape;
+  static_assert(kShape.is_large());
+  constexpr int kOverBytes =
+      kShape.packed_max_spread_bytes() - kShape.unpacked_byte_size();
+
+  Plan plan = {};
+
+  int packed_start_bit = 0;
+  for (int r = 0; r < Plan::kReadsPerKernel; ++r) {
+    const int read_start_byte = packed_start_bit / 8;
+    plan.reads.at(r) = read_start_byte;
+
+    constexpr int kUndefined = -1;
+    plan.low_swizzles.at(r) = BuildConstantArray<typename Plan::Swizzle>(kUndefined);
+    plan.high_swizzles.at(r) = BuildConstantArray<typename Plan::Swizzle>(kUndefined);
+
+    for (int u = 0; u < kShape.unpacked_per_simd(); ++u) {
+      const int packed_start_byte = packed_start_bit / 8;
+      const int packed_byte_in_read = packed_start_byte - read_start_byte;
+
+      // Looping over maximum number of bytes that can fit a value
+      // We fill more than necessary in the high swizzle because in the absence of
+      // variable right shifts, we will erase some bits from the low sizzled values.
+      for (int b = 0; b < kShape.unpacked_byte_size(); ++b) {
+        const auto idx = u * kShape.unpacked_byte_size() + b;
+        plan.low_swizzles.at(r).at(idx) = packed_byte_in_read + b;
+        plan.high_swizzles.at(r).at(idx) = packed_byte_in_read + b + kOverBytes;
+      }
+
+      // low and high swizzles need to be rshifted but the oversized bytes created a
+      // larger lshift for high values.
+      plan.low_rshifts.at(r).at(u) = packed_start_bit % 8;
+      plan.high_lshifts.at(r).at(u) = 8 * kOverBytes - (packed_start_bit % 8);
+
+      packed_start_bit += kShape.packed_bit_size();
+    }
+  }
+
+  plan.mask = bit_util::LeastSignificantBitMask<uint_type>(kShape.packed_bit_size());
+
+  return plan;
+}
+
+template <typename KernelTraits>
+struct LargeKernel {
+  static constexpr auto kPlan = BuildLargePlan<KernelTraits>();
+  static constexpr auto kShape = kPlan.kShape;
+  using Traits = typename decltype(kPlan)::Traits;
+  using unpacked_type = typename Traits::unpacked_type;
+  using simd_batch = typename Traits::simd_batch;
+  using simd_bytes = typename Traits::simd_bytes;
+  using arch_type = typename Traits::arch_type;
+
+  static constexpr int kValuesUnpacked = kPlan.kUnpackedPerkernel;
+  static constexpr int kBytesRead = kPlan.total_bytes_read();
+
+  template <int kReadIdx>
+  static void unpack_one_read_impl(const uint8_t* in, unpacked_type* out) {
+    constexpr auto kLowSwizzles =
+        array_to_batch_constant<kPlan.low_swizzles.at(kReadIdx), arch_type>();
+    constexpr auto kLowRShifts =
+        array_to_batch_constant<kPlan.low_rshifts.at(kReadIdx), arch_type>();
+    constexpr auto kHighSwizzles =
+        array_to_batch_constant<kPlan.high_swizzles.at(kReadIdx), arch_type>();
+    constexpr auto kHighLShifts =
+        array_to_batch_constant<kPlan.high_lshifts.at(kReadIdx), arch_type>();
+
+    const auto bytes =
+        load_bytes<kPlan.bytes_per_read(), arch_type>(in + kPlan.reads.at(kReadIdx));
+
+    const auto low_swizzled = swizzle_bytes(bytes, kLowSwizzles);
+    const auto low_words = xsimd::bitwise_cast<unpacked_type>(low_swizzled);
+    simd_batch low_shifted;
+    if constexpr (kShape.unpacked_byte_size() == 1 && HasSse2<arch_type>) {
+      // The logic of the fallback in right_shift_by_excess does not work for this single
+      // byte case case, so we use directly xsimd and its scalar fallback.
+      low_shifted = low_words >> kLowRShifts;
+    } else {
+      low_shifted = right_shift_by_excess(low_words, kLowRShifts);
+    }
+
+    const auto high_swizzled = swizzle_bytes(bytes, kHighSwizzles);
+    const auto high_words = xsimd::bitwise_cast<unpacked_type>(high_swizzled);
+    const auto high_shifted = left_shift(high_words, kHighLShifts);
+
+    // We can have a single mask and apply it after OR because the shifts will ensure that
+    // there are zeros where the high/low values are incomplete.
+    const auto vals = (low_shifted | high_shifted) & kPlan.mask;
+    xsimd::store_unaligned(out + kReadIdx * kShape.unpacked_per_simd(), vals);
+  }
+
+  template <int... kReadIds>
+  static void unpack_all_impl(const uint8_t* in, unpacked_type* out,
+                              std::integer_sequence<int, kReadIds...>) {
+    (unpack_one_read_impl<kReadIds>(in, out), ...);
+  }
+
+  static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
+    using ReadSeq = std::make_integer_sequence<int, kPlan.kReadsPerKernel>;
+    unpack_all_impl(in, out, ReadSeq{});
+    return in + (kPlan.kUnpackedPerkernel * kShape.packed_bit_size()) / 8;
+  }
+};
+
+/*********************
+ *  Utility Kernels  *
+ *********************/
+
+/// A Kernel that does not extract anything, leaving all work to the naive implementation.
+template <typename KernelTraits>
+struct NoOpKernel {
+  using unpacked_type = typename KernelTraits::unpacked_type;
+
+  static constexpr int kValuesUnpacked = 0;
+  static constexpr int kBytesRead = 0;
+
+  static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) { return in; }
+};
+
+template <typename KernelTraits, typename WorkingKernel>
+struct ForwardToKernel : WorkingKernel {
+  using unpacked_type = typename KernelTraits::unpacked_type;
+
+  static constexpr int kValuesUnpacked = WorkingKernel::kValuesUnpacked;
+
+  static const uint8_t* unpack(const uint8_t* in, unpacked_type* out) {
+    using working_type = typename WorkingKernel::unpacked_type;
+
+    working_type buffer[kValuesUnpacked] = {};
+    in = WorkingKernel::unpack(in, buffer);
+    for (int k = 0; k < kValuesUnpacked; ++k) {
+      out[k] = static_cast<unpacked_type>(buffer[k]);
+    }
+    return in;
+  }
+};
+
+/*******************************
+ *  Kernel static dispatching  *
+ *******************************/
+
+// Benchmarking show unpack to uint64_t is underperforming on SSE4.2 and Avx2
+template <typename Traits, typename Arch = typename Traits::arch_type>
+constexpr bool MediumShouldUseUint32 =
+    (HasSse2<Arch> || HasSse2<Arch>)&&  //
+    (Traits::kShape.unpacked_byte_size() == sizeof(uint64_t)) &&
+    (Traits::kShape.packed_bit_size() < 32) &&
+    KernelTraitsWithUnpack<Traits, uint32_t>::kShape.is_medium();
+
+// Benchmarking show large unpack to uint8_t is underperforming on SSE4.2
+template <typename Traits, typename Arch = typename Traits::arch_type>
+constexpr bool LargeShouldUseUint16 = HasSse2<Arch> &&
+                                      (Traits::kShape.unpacked_byte_size() ==
+                                       sizeof(uint8_t));
+
+// A ``std::enable_if`` that works on MSVC
+template <typename Traits>
+constexpr auto KernelDispatchImpl() {
+  if constexpr (Traits::kShape.is_medium()) {
+    if constexpr (MediumShouldUseUint32<Traits>) {
+      using Kernel32 = MediumKernel<KernelTraitsWithUnpack<Traits, uint32_t>>;
+      return ForwardToKernel<Traits, Kernel32>{};
+    } else {
+      return MediumKernel<Traits>{};
+    }
+  } else if constexpr (Traits::kShape.is_large()) {
+    if constexpr (LargeShouldUseUint16<Traits>) {
+      using Kernel16 = MediumKernel<KernelTraitsWithUnpack<Traits, uint16_t>>;
+      return ForwardToKernel<Traits, Kernel16>{};
+    } else {
+      return LargeKernel<Traits>{};
+    }
+  } else if constexpr (Traits::kShape.is_oversized()) {
+    return NoOpKernel<Traits>{};
+  }
+}
+
+template <typename Traits>
+using KernelDispatch = decltype(KernelDispatchImpl<Traits>());
+
+/// The public kernel exposed for any size.
+template <typename UnpackedUint, int kPackedBitSize, int kSimdBitSize>
+struct Kernel : KernelDispatch<KernelTraits<UnpackedUint, kPackedBitSize, kSimdBitSize>> {
+};
+
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/util/bpacking_test.cc b/cpp/src/arrow/util/bpacking_test.cc
index a3ab4d6dda2..3e9066a91eb 100644
--- a/cpp/src/arrow/util/bpacking_test.cc
+++ b/cpp/src/arrow/util/bpacking_test.cc
@@ -34,7 +34,7 @@
 namespace arrow::internal {
 
 template <typename Int>
-using UnpackFunc = void (*)(const uint8_t*, Int*, int, int, int);
+using UnpackFunc = void (*)(const uint8_t*, Int*, const UnpackOptions&);
 
 /// Get the number of bytes associate with a packing.
 int GetNumBytes(int num_values, int bit_width, int bit_offset) {
@@ -64,17 +64,16 @@ std::vector<Uint> GenerateRandomValuesForPacking(int num_values, int bit_width)
 
 /// Convenience wrapper to unpack into a vector
 template <typename Int>
-std::vector<Int> UnpackValues(const uint8_t* packed, int32_t num_values,
-                              int32_t bit_width, int32_t bit_offset,
+std::vector<Int> UnpackValues(const uint8_t* packed, const UnpackOptions& opts,
                               UnpackFunc<Int> unpack) {
   if constexpr (std::is_same_v<Int, bool>) {
     // Using dynamic array to avoid std::vector<bool>
-    auto buffer = std::make_unique<Int[]>(num_values);
-    unpack(packed, buffer.get(), num_values, bit_width, bit_offset);
-    return std::vector<Int>(buffer.get(), buffer.get() + num_values);
+    auto buffer = std::make_unique<Int[]>(opts.batch_size);
+    unpack(packed, buffer.get(), opts);
+    return std::vector<Int>(buffer.get(), buffer.get() + opts.batch_size);
   } else {
-    std::vector<Int> out(num_values);
-    unpack(packed, out.data(), num_values, bit_width, bit_offset);
+    std::vector<Int> out(opts.batch_size);
+    unpack(packed, out.data(), opts);
     return out;
   }
 }
@@ -108,77 +107,84 @@ std::vector<uint8_t> PackValues(const std::vector<Int>& values, int num_values,
 class TestUnpack : public ::testing::TestWithParam<int> {
  protected:
   template <typename Int>
-  void TestRoundtripAlignment(UnpackFunc<Int> unpack, int num_values, int bit_width,
-                              int bit_offset) {
-    const auto original = GenerateRandomValuesForPacking<Int>(num_values, bit_width);
-    const auto packed = PackValues(original, num_values, bit_width, bit_offset);
-    const auto unpacked =
-        UnpackValues(packed.data(), num_values, bit_width, bit_offset, unpack);
-    EXPECT_EQ(unpacked.size(), num_values);
-    EXPECT_EQ(original, unpacked);
+  void TestRoundtripAlignment(UnpackFunc<Int> unpack, const UnpackOptions& opts) {
+    const auto original =
+        GenerateRandomValuesForPacking<Int>(opts.batch_size, opts.bit_width);
+    const auto packed =
+        PackValues(original, opts.batch_size, opts.bit_width, opts.bit_offset);
+    const auto unpacked = UnpackValues(packed.data(), opts, unpack);
+
+    ASSERT_EQ(unpacked.size(), opts.batch_size);
+    const auto [iter_original, iter_unpacked] =
+        std::mismatch(original.cbegin(), original.cend(), unpacked.cbegin());
+    Int val_original = 0;
+    Int val_unpacked = 0;
+    const auto mismatch_idx = static_cast<std::size_t>(iter_original - original.cbegin());
+    if (mismatch_idx < unpacked.size()) {
+      val_original = *iter_original;
+      val_unpacked = *iter_unpacked;
+    }
+    EXPECT_EQ(original, unpacked) << "At position " << mismatch_idx << "/"
+                                  << unpacked.size() << ", expected original value "
+                                  << val_original << " but unpacked " << val_unpacked;
   }
 
   template <typename Int>
-  void TestUnpackZeros(UnpackFunc<Int> unpack, int num_values, int bit_width,
-                       int bit_offset) {
-    const auto num_bytes = GetNumBytes(num_values, bit_width, bit_offset);
+  void TestUnpackZeros(UnpackFunc<Int> unpack, const UnpackOptions& opts) {
+    const auto num_bytes = GetNumBytes(opts.batch_size, opts.bit_width, opts.bit_offset);
 
     const std::vector<uint8_t> packed(static_cast<std::size_t>(num_bytes), uint8_t{0});
-    const auto unpacked =
-        UnpackValues(packed.data(), num_values, bit_width, bit_offset, unpack);
+    const auto unpacked = UnpackValues(packed.data(), opts, unpack);
 
-    const std::vector<Int> expected(static_cast<std::size_t>(num_values), Int{0});
+    const std::vector<Int> expected(static_cast<std::size_t>(opts.batch_size), Int{0});
     EXPECT_EQ(unpacked, expected);
   }
 
   template <typename Int>
-  void TestUnpackOnes(UnpackFunc<Int> unpack, int num_values, int bit_width,
-                      int bit_offset) {
-    const auto num_bytes = GetNumBytes(num_values, bit_width, bit_offset);
+  void TestUnpackOnes(UnpackFunc<Int> unpack, const UnpackOptions& opts) {
+    const auto num_bytes = GetNumBytes(opts.batch_size, opts.bit_width, opts.bit_offset);
 
     const std::vector<uint8_t> packed(static_cast<std::size_t>(num_bytes), uint8_t{0xFF});
-    const auto unpacked =
-        UnpackValues(packed.data(), num_values, bit_width, bit_offset, unpack);
+    const auto unpacked = UnpackValues(packed.data(), opts, unpack);
 
     // Generate bit_width ones
     Int expected_value = 0;
     if constexpr (std::is_same_v<Int, bool>) {
-      expected_value = static_cast<bool>(bit_width);
+      expected_value = static_cast<bool>(opts.bit_width);
     } else {
-      for (int i = 0; i < bit_width; ++i) {
+      for (int i = 0; i < opts.bit_width; ++i) {
         expected_value = (expected_value << 1) | 1;
       }
     }
-    const std::vector<Int> expected(static_cast<std::size_t>(num_values), expected_value);
+    const std::vector<Int> expected(static_cast<std::size_t>(opts.batch_size),
+                                    expected_value);
     EXPECT_EQ(unpacked, expected);
   }
 
   template <typename Int>
-  void TestUnpackAlternating(UnpackFunc<Int> unpack, int num_values, int bit_width,
-                             int bit_offset) {
-    const auto num_bytes = GetNumBytes(num_values, bit_width, bit_offset);
+  void TestUnpackAlternating(UnpackFunc<Int> unpack, const UnpackOptions& opts) {
+    const auto num_bytes = GetNumBytes(opts.batch_size, opts.bit_width, opts.bit_offset);
 
     // Pick between two different bit patterns so that we always unpack starting with 1
-    const uint8_t byte = bit_offset % 2 == 0 ? 0b10101010 : 0b01010101;
+    const uint8_t byte = opts.bit_offset % 2 == 0 ? 0b10101010 : 0b01010101;
     const std::vector<uint8_t> packed(static_cast<std::size_t>(num_bytes), byte);
-    const auto unpacked =
-        UnpackValues(packed.data(), num_values, bit_width, bit_offset, unpack);
+    const auto unpacked = UnpackValues(packed.data(), opts, unpack);
 
     // Generate alternative bit sequence starting with either 0 or 1
     Int one_zero_value = 0;
     Int zero_one_value = 0;
-    for (int i = 0; i < bit_width; ++i) {
+    for (int i = 0; i < opts.bit_width; ++i) {
       zero_one_value = (zero_one_value << 1) | (i % 2);
       one_zero_value = (one_zero_value << 1) | ((i + 1) % 2);
     }
 
     std::vector<Int> expected;
-    if (bit_width % 2 == 0) {
+    if (opts.bit_width % 2 == 0) {
       // For even bit_width, the same pattern repeats every time
-      expected.resize(static_cast<std::size_t>(num_values), one_zero_value);
+      expected.resize(static_cast<std::size_t>(opts.batch_size), one_zero_value);
     } else {
       // For odd bit_width, we alternate a pattern leading with 0 and 1
-      for (int i = 0; i < num_values; ++i) {
+      for (int i = 0; i < opts.batch_size; ++i) {
         expected.push_back(i % 2 == 0 ? zero_one_value : one_zero_value);
       }
     }
@@ -201,31 +207,45 @@ class TestUnpack : public ::testing::TestWithParam<int> {
       for (int bit_offset = 0; bit_offset < 8; ++bit_offset) {
         SCOPED_TRACE(::testing::Message() << "Testing bit_offset=" << bit_offset);
 
+        const UnpackOptions opts{
+            /* .batch_size= */ num_values_base,
+            /* .bit_width= */ bit_width,
+            /* .bit_offset= */ bit_offset,
+            /* .max_read_bytes= */ -1,  // No over-reading in testing (strict ASAN)
+        };
+
         // Known values
-        TestUnpackZeros(unpack, num_values_base, bit_width, bit_offset);
-        TestUnpackOnes(unpack, num_values_base, bit_width, bit_offset);
-        TestUnpackAlternating(unpack, num_values_base, bit_width, bit_offset);
+        TestUnpackZeros(unpack, opts);
+        TestUnpackOnes(unpack, opts);
+        TestUnpackAlternating(unpack, opts);
 
         // Roundtrips
-        TestRoundtripAlignment(unpack, num_values_base, bit_width, bit_offset);
+        TestRoundtripAlignment(unpack, opts);
 
         if (testing::Test::HasFailure()) return;
       }
 
-      // Similarly, we test all epilogue sizes. That is extra values that could make it
+      // Similarly, we test all epilog sizes. That is extra values that could make it
       // fall outside of an SIMD register
       for (int epilogue_size = 0; epilogue_size <= kMaxBitWidth; ++epilogue_size) {
-        SCOPED_TRACE(::testing::Message() << "Testing epilogue_size=" << epilogue_size);
+        SCOPED_TRACE(::testing::Message() << "Testing epilog_size=" << epilogue_size);
 
         const int num_values = num_values_base + epilogue_size;
 
+        const UnpackOptions opts{
+            /* .batch_size= */ num_values,
+            /* .bit_width= */ bit_width,
+            /* .bit_offset= */ 0,
+            /* .max_read_bytes= */ -1,  // No over-reading in testing (strict ASAN)
+        };
+
         // Known values
-        TestUnpackZeros(unpack, num_values, bit_width, /* bit_offset= */ 0);
-        TestUnpackOnes(unpack, num_values, bit_width, /* bit_offset= */ 0);
-        TestUnpackAlternating(unpack, num_values, bit_width, /* bit_offset= */ 0);
+        TestUnpackZeros(unpack, opts);
+        TestUnpackOnes(unpack, opts);
+        TestUnpackAlternating(unpack, opts);
 
         // Roundtrips
-        TestRoundtripAlignment(unpack, num_values, bit_width, /* bit_offset= */ 0);
+        TestRoundtripAlignment(unpack, opts);
 
         if (testing::Test::HasFailure()) return;
       }
@@ -247,6 +267,14 @@ TEST_P(TestUnpack, Unpack16Scalar) { this->TestAll(&unpack_scalar<uint16_t>); }
 TEST_P(TestUnpack, Unpack32Scalar) { this->TestAll(&unpack_scalar<uint32_t>); }
 TEST_P(TestUnpack, Unpack64Scalar) { this->TestAll(&unpack_scalar<uint64_t>); }
 
+#if defined(ARROW_HAVE_SSE4_2)
+TEST_P(TestUnpack, UnpackBoolSse4_2) { this->TestAll(&unpack_sse4_2<bool>); }
+TEST_P(TestUnpack, Unpack8Sse4_2) { this->TestAll(&unpack_sse4_2<uint8_t>); }
+TEST_P(TestUnpack, Unpack16Sse4_2) { this->TestAll(&unpack_sse4_2<uint16_t>); }
+TEST_P(TestUnpack, Unpack32Sse4_2) { this->TestAll(&unpack_sse4_2<uint32_t>); }
+TEST_P(TestUnpack, Unpack64Sse4_2) { this->TestAll(&unpack_sse4_2<uint64_t>); }
+#endif
+
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
 TEST_P(TestUnpack, UnpackBoolAvx2) {
   if (!CpuInfo::GetInstance()->IsSupported(CpuInfo::AVX2)) {
diff --git a/cpp/src/arrow/util/rle_encoding_internal.h b/cpp/src/arrow/util/rle_encoding_internal.h
index 2c084e0b4c8..e1c5d6eaea8 100644
--- a/cpp/src/arrow/util/rle_encoding_internal.h
+++ b/cpp/src/arrow/util/rle_encoding_internal.h
@@ -157,10 +157,12 @@ class BitPackedRun {
   constexpr BitPackedRun() noexcept = default;
 
   constexpr BitPackedRun(const uint8_t* data, rle_size_t values_count,
-                         rle_size_t value_bit_width) noexcept
-      : data_(data), values_count_(values_count) {
+                         rle_size_t value_bit_width, rle_size_t max_read_bytes) noexcept
+      : data_(data), values_count_(values_count), max_read_bytes_(max_read_bytes) {
     ARROW_CHECK_GE(value_bit_width, 0);
     ARROW_CHECK_GE(values_count_, 0);
+    ARROW_CHECK(max_read_bytes < 0 ||
+                bit_util::BytesForBits(value_bit_width * values_count) <= max_read_bytes);
   }
 
   constexpr rle_size_t values_count() const noexcept { return values_count_; }
@@ -174,11 +176,18 @@ class BitPackedRun {
     return static_cast<rle_size_t>(out);
   }
 
+  /// Maximum number of bytes allowed to be read in the buffer.
+  /// This is used for unpacking operations that may need to read more bytes than they
+  /// extract for performance.
+  constexpr rle_size_t raw_data_max_size() const noexcept { return max_read_bytes_; }
+
  private:
   /// The pointer to the beginning of the run
   const uint8_t* data_ = nullptr;
   /// Number of values in this run.
   rle_size_t values_count_ = 0;
+  /// Not the size of the run, but the maximum number of bytes we can read in the buffer.
+  rle_size_t max_read_bytes_ = -1;
 };
 
 /// A parser that emits either a ``BitPackedRun`` or a ``RleRun``.
@@ -337,6 +346,7 @@ class BitPackedRunDecoder {
     data_ = run.raw_data_ptr();
     values_count_ = run.values_count();
     values_read_ = 0;
+    max_read_bytes_ = run.raw_data_max_size();
   }
 
   /// Return the number of values that can be advanced.
@@ -360,21 +370,26 @@ class BitPackedRunDecoder {
   /// left.
   [[nodiscard]] rle_size_t GetBatch(value_type* out, rle_size_t batch_size,
                                     rle_size_t value_bit_width) {
-    const auto steps = std::min(batch_size, remaining());
-    const auto bits_read = values_read_ * value_bit_width;
-    const auto* unread_data = data_ + bits_read / 8;
-    const auto bit_offset = bits_read % 8;
+    const int bits_read = values_read_ * value_bit_width;
+    const int bytes_fully_read = bits_read / 8;
+    const uint8_t* unread_data = data_ + bytes_fully_read;
+
+    const ::arrow::internal::UnpackOptions opts{
+        /* .batch_size= */ std::min(batch_size, remaining()),
+        /* .bit_width= */ value_bit_width,
+        /* .bit_offset= */ bits_read % 8,
+        /* .max_read_bytes= */ max_read_bytes_ - bytes_fully_read,
+    };
 
     if constexpr (std::is_same_v<T, bool>) {
-      ::arrow::internal::unpack(unread_data, out, steps, value_bit_width, bit_offset);
+      ::arrow::internal::unpack(unread_data, out, opts);
 
     } else {
-      ::arrow::internal::unpack(unread_data,
-                                reinterpret_cast<std::make_unsigned_t<value_type>*>(out),
-                                steps, value_bit_width, bit_offset);
+      ::arrow::internal::unpack(
+          unread_data, reinterpret_cast<std::make_unsigned_t<value_type>*>(out), opts);
     }
-    values_read_ += steps;
-    return steps;
+    values_read_ += opts.batch_size;
+    return opts.batch_size;
   }
 
  private:
@@ -384,6 +399,8 @@ class BitPackedRunDecoder {
   rle_size_t values_count_ = 0;
   /// The number of values read by the decoder
   rle_size_t values_read_ = 0;
+  /// Total number of bytes in the buffer that we can over-read.
+  rle_size_t max_read_bytes_ = -1;
 
   static_assert(std::is_integral_v<value_type>,
                 "This class is meant to decode positive integers");
@@ -703,7 +720,8 @@ auto RleBitPackedParser::PeekImpl(Handler&& handler) const
     }
 
     auto control = handler.OnBitPackedRun(
-        BitPackedRun(data_ + header_bytes, values_count, value_bit_width_));
+        BitPackedRun(data_ + header_bytes, values_count, value_bit_width_,
+                     /* .max_read_bytes= */ data_size_ - header_bytes));
 
     return {static_cast<rle_size_t>(bytes_read), control};
   }
diff --git a/cpp/src/arrow/util/rle_encoding_test.cc b/cpp/src/arrow/util/rle_encoding_test.cc
index b2d4f7df6f1..44d291acbba 100644
--- a/cpp/src/arrow/util/rle_encoding_test.cc
+++ b/cpp/src/arrow/util/rle_encoding_test.cc
@@ -258,7 +258,8 @@ TEST(BitPacked, BitPackedRun) {
   // 16 values of 1 bit for a total of 16 bits
   const rle_size_t value_count_1 = 16;
   const rle_size_t value_bit_width_1 = 1;
-  const auto run_1 = BitPackedRun(value.data(), value_count_1, value_bit_width_1);
+  const auto run_1 = BitPackedRun(value.data(), value_count_1, value_bit_width_1,
+                                  /* .max_read_bytes= */ -1);
   EXPECT_EQ(run_1.values_count(), value_count_1);
   EXPECT_EQ(run_1.raw_data_size(value_bit_width_1), 2);  // 16 bits fit in 2 bytes
   EXPECT_EQ(run_1.raw_data_ptr(), value.data());
@@ -266,7 +267,8 @@ TEST(BitPacked, BitPackedRun) {
   // 8 values of 3 bits for a total of 24 bits
   const rle_size_t value_count_3 = 8;
   const rle_size_t value_bit_width_3 = 3;
-  const auto run_3 = BitPackedRun(value.data(), value_count_3, value_bit_width_3);
+  const auto run_3 = BitPackedRun(value.data(), value_count_3, value_bit_width_3,
+                                  /* .max_read_bytes= */ -1);
   EXPECT_EQ(run_3.values_count(), value_count_3);
   EXPECT_EQ(run_3.raw_data_size(value_bit_width_3), 3);  // 24 bits fit in 3 bytes
   EXPECT_EQ(run_3.raw_data_ptr(), value.data());
@@ -338,7 +340,8 @@ void TestBitPackedDecoder(std::vector<uint8_t> bytes, rle_size_t value_count,
   // Pre-requisite for this test
   EXPECT_GT(value_count, 6);
 
-  const auto run = BitPackedRun(bytes.data(), value_count, bit_width);
+  const auto run =
+      BitPackedRun(bytes.data(), value_count, bit_width, /* .max_read_bytes= */ -1);
 
   auto decoder = BitPackedRunDecoder<T>(run, bit_width);
   std::vector<T> vals = {0, 0};
diff --git a/cpp/src/arrow/util/type_traits.h b/cpp/src/arrow/util/type_traits.h
index 9c3b388dab2..dfd968670fb 100644
--- a/cpp/src/arrow/util/type_traits.h
+++ b/cpp/src/arrow/util/type_traits.h
@@ -69,5 +69,9 @@ struct SizedIntImpl<8> {
 template <int kNumBytes>
 using SizedInt = typename SizedIntImpl<kNumBytes>::type;
 
+// Map a number of bytes to a type
+template <int kNumBytes>
+using SizedUint = std::make_unsigned_t<SizedInt<kNumBytes>>;
+
 }  // namespace internal
 }  // namespace arrow