duckdb 0.3.2-dev396.0 → 0.3.2-dev454.0

package/src/duckdb.cpp

@@ -80621,6 +80621,11 @@ struct RLEFun {
 	static bool TypeIsSupported(PhysicalType type);
 };
 
+struct BitpackingFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
 } // namespace duckdb
 
 
@@ -80640,6 +80645,7 @@ static DefaultCompressionMethod internal_compression_methods[] = {
     {CompressionType::COMPRESSION_CONSTANT, ConstantFun::GetFunction, ConstantFun::TypeIsSupported},
     {CompressionType::COMPRESSION_UNCOMPRESSED, UncompressedFun::GetFunction, UncompressedFun::TypeIsSupported},
     {CompressionType::COMPRESSION_RLE, RLEFun::GetFunction, RLEFun::TypeIsSupported},
+    {CompressionType::COMPRESSION_BITPACKING, BitpackingFun::GetFunction, BitpackingFun::TypeIsSupported},
     {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
 
 static CompressionFunction *FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
@@ -80688,6 +80694,7 @@ vector<CompressionFunction *> DBConfig::GetCompressionFunctions(PhysicalType dat
 	vector<CompressionFunction *> result;
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_UNCOMPRESSED, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_RLE, data_type);
+	TryLoadCompression(*this, result, CompressionType::COMPRESSION_BITPACKING, data_type);
 	return result;
 }
 
@@ -159282,56 +159289,1170 @@ void PartialBlock::FlushToDisk(DatabaseInstance &db) {
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/segment/uncompressed.hpp
-//
-//
-//===----------------------------------------------------------------------===//
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
+
+/**
+* This code is released under the
+* Apache License Version 2.0 http://www.apache.org/licenses/.
+*
+* (c) Daniel Lemire, http://lemire.me/en/
+*/
+
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
 
-namespace duckdb {
-class DatabaseInstance;
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://fastpforlib.me/en/
+ */
 
-struct UncompressedFunctions {
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
-	                                                    unique_ptr<AnalyzeState> state);
-	static void Compress(CompressionState &state_p, Vector &data, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-	static void EmptySkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+#include <cinttypes>
+#include <string>
+
+namespace duckdb_fastpforlib {
+namespace internal {
+
+// Unpacks 8 uint8_t values
+void __fastunpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
+
+// Unpacks 16 uint16_t values
+void __fastunpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
+
+// Unpacks 32 uint32_t values
+void __fastunpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
+
+// Unpacks 32 uint64_t values
+void __fastunpack0(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out);
+
+// Packs 8 int8_t values
+void __fastpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
+
+// Packs 16 int16_t values
+void __fastpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
+
+// Packs 32 int32_t values
+void __fastpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
+
+// Packs 32 int64_t values
+void __fastpack0(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out);
+} // namespace internal
+} // namespace duckdb_fastpforlib
+
+
+// LICENSE_CHANGE_END
+
+
+#include <stdexcept>
+
+namespace duckdb_fastpforlib {
+
+namespace internal {
+
+// Note that this only packs 8 values
+inline void fastunpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastunpack0(in, out);
+		break;
+	case 1:
+		internal::__fastunpack1(in, out);
+		break;
+	case 2:
+		internal::__fastunpack2(in, out);
+		break;
+	case 3:
+		internal::__fastunpack3(in, out);
+		break;
+	case 4:
+		internal::__fastunpack4(in, out);
+		break;
+	case 5:
+		internal::__fastunpack5(in, out);
+		break;
+	case 6:
+		internal::__fastunpack6(in, out);
+		break;
+	case 7:
+		internal::__fastunpack7(in, out);
+		break;
+	case 8:
+		internal::__fastunpack8(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
 	}
-};
+}
 
-struct FixedSizeUncompressed {
-	static CompressionFunction GetFunction(PhysicalType data_type);
-};
+// Note that this only packs 8 values
+inline void fastpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastpack0(in, out);
+		break;
+	case 1:
+		internal::__fastpack1(in, out);
+		break;
+	case 2:
+		internal::__fastpack2(in, out);
+		break;
+	case 3:
+		internal::__fastpack3(in, out);
+		break;
+	case 4:
+		internal::__fastpack4(in, out);
+		break;
+	case 5:
+		internal::__fastpack5(in, out);
+		break;
+	case 6:
+		internal::__fastpack6(in, out);
+		break;
+	case 7:
+		internal::__fastpack7(in, out);
+		break;
+	case 8:
+		internal::__fastpack8(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
 
-struct ValidityUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
+// Note that this only packs 16 values
+inline void fastunpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastunpack0(in, out);
+		break;
+	case 1:
+		internal::__fastunpack1(in, out);
+		break;
+	case 2:
+		internal::__fastunpack2(in, out);
+		break;
+	case 3:
+		internal::__fastunpack3(in, out);
+		break;
+	case 4:
+		internal::__fastunpack4(in, out);
+		break;
+	case 5:
+		internal::__fastunpack5(in, out);
+		break;
+	case 6:
+		internal::__fastunpack6(in, out);
+		break;
+	case 7:
+		internal::__fastunpack7(in, out);
+		break;
+	case 8:
+		internal::__fastunpack8(in, out);
+		break;
+	case 9:
+		internal::__fastunpack9(in, out);
+		break;
+	case 10:
+		internal::__fastunpack10(in, out);
+		break;
+	case 11:
+		internal::__fastunpack11(in, out);
+		break;
+	case 12:
+		internal::__fastunpack12(in, out);
+		break;
+	case 13:
+		internal::__fastunpack13(in, out);
+		break;
+	case 14:
+		internal::__fastunpack14(in, out);
+		break;
+	case 15:
+		internal::__fastunpack15(in, out);
+		break;
+	case 16:
+		internal::__fastunpack16(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
 
-public:
-	static const validity_t LOWER_MASKS[65];
-	static const validity_t UPPER_MASKS[65];
-};
+// Note that this only packs 16 values
+inline void fastpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastpack0(in, out);
+		break;
+	case 1:
+		internal::__fastpack1(in, out);
+		break;
+	case 2:
+		internal::__fastpack2(in, out);
+		break;
+	case 3:
+		internal::__fastpack3(in, out);
+		break;
+	case 4:
+		internal::__fastpack4(in, out);
+		break;
+	case 5:
+		internal::__fastpack5(in, out);
+		break;
+	case 6:
+		internal::__fastpack6(in, out);
+		break;
+	case 7:
+		internal::__fastpack7(in, out);
+		break;
+	case 8:
+		internal::__fastpack8(in, out);
+		break;
+	case 9:
+		internal::__fastpack9(in, out);
+		break;
+	case 10:
+		internal::__fastpack10(in, out);
+		break;
+	case 11:
+		internal::__fastpack11(in, out);
+		break;
+	case 12:
+		internal::__fastpack12(in, out);
+		break;
+	case 13:
+		internal::__fastpack13(in, out);
+		break;
+	case 14:
+		internal::__fastpack14(in, out);
+		break;
+	case 15:
+		internal::__fastpack15(in, out);
+		break;
+	case 16:
+		internal::__fastpack16(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
+}
 
-struct StringUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
+inline void fastunpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	for (uint8_t i = 0; i < 4; i++) {
+		internal::fastunpack_quarter(in + (i*bit), out+(i*8), bit);
+	}
+}
 
-public:
-	//! The max string size that is allowed within a block. Strings bigger than this will be labeled as a BIG STRING and
-	//! offloaded to the overflow blocks.
-	static constexpr uint16_t STRING_BLOCK_LIMIT = 4096;
-};
+inline void fastunpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	internal::fastunpack_half(in, out, bit);
+	internal::fastunpack_half(in + bit, out+16, bit);
+}
 
-} // namespace duckdb
+inline void fastunpack(const uint32_t *__restrict in,
+                       uint32_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastunpack0(in, out);
+    break;
+  case 1:
+    internal::__fastunpack1(in, out);
+    break;
+  case 2:
+    internal::__fastunpack2(in, out);
+    break;
+  case 3:
+    internal::__fastunpack3(in, out);
+    break;
+  case 4:
+    internal::__fastunpack4(in, out);
+    break;
+  case 5:
+    internal::__fastunpack5(in, out);
+    break;
+  case 6:
+    internal::__fastunpack6(in, out);
+    break;
+  case 7:
+    internal::__fastunpack7(in, out);
+    break;
+  case 8:
+    internal::__fastunpack8(in, out);
+    break;
+  case 9:
+    internal::__fastunpack9(in, out);
+    break;
+  case 10:
+    internal::__fastunpack10(in, out);
+    break;
+  case 11:
+    internal::__fastunpack11(in, out);
+    break;
+  case 12:
+    internal::__fastunpack12(in, out);
+    break;
+  case 13:
+    internal::__fastunpack13(in, out);
+    break;
+  case 14:
+    internal::__fastunpack14(in, out);
+    break;
+  case 15:
+    internal::__fastunpack15(in, out);
+    break;
+  case 16:
+    internal::__fastunpack16(in, out);
+    break;
+  case 17:
+    internal::__fastunpack17(in, out);
+    break;
+  case 18:
+    internal::__fastunpack18(in, out);
+    break;
+  case 19:
+    internal::__fastunpack19(in, out);
+    break;
+  case 20:
+    internal::__fastunpack20(in, out);
+    break;
+  case 21:
+    internal::__fastunpack21(in, out);
+    break;
+  case 22:
+    internal::__fastunpack22(in, out);
+    break;
+  case 23:
+    internal::__fastunpack23(in, out);
+    break;
+  case 24:
+    internal::__fastunpack24(in, out);
+    break;
+  case 25:
+    internal::__fastunpack25(in, out);
+    break;
+  case 26:
+    internal::__fastunpack26(in, out);
+    break;
+  case 27:
+    internal::__fastunpack27(in, out);
+    break;
+  case 28:
+    internal::__fastunpack28(in, out);
+    break;
+  case 29:
+    internal::__fastunpack29(in, out);
+    break;
+  case 30:
+    internal::__fastunpack30(in, out);
+    break;
+  case 31:
+    internal::__fastunpack31(in, out);
+    break;
+  case 32:
+    internal::__fastunpack32(in, out);
+    break;
+  default:
+    throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastunpack(const uint32_t *__restrict in,
+                       uint64_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastunpack0(in, out);
+    break;
+  case 1:
+    internal::__fastunpack1(in, out);
+    break;
+  case 2:
+    internal::__fastunpack2(in, out);
+    break;
+  case 3:
+    internal::__fastunpack3(in, out);
+    break;
+  case 4:
+    internal::__fastunpack4(in, out);
+    break;
+  case 5:
+    internal::__fastunpack5(in, out);
+    break;
+  case 6:
+    internal::__fastunpack6(in, out);
+    break;
+  case 7:
+    internal::__fastunpack7(in, out);
+    break;
+  case 8:
+    internal::__fastunpack8(in, out);
+    break;
+  case 9:
+    internal::__fastunpack9(in, out);
+    break;
+  case 10:
+    internal::__fastunpack10(in, out);
+    break;
+  case 11:
+    internal::__fastunpack11(in, out);
+    break;
+  case 12:
+    internal::__fastunpack12(in, out);
+    break;
+  case 13:
+    internal::__fastunpack13(in, out);
+    break;
+  case 14:
+    internal::__fastunpack14(in, out);
+    break;
+  case 15:
+    internal::__fastunpack15(in, out);
+    break;
+  case 16:
+    internal::__fastunpack16(in, out);
+    break;
+  case 17:
+    internal::__fastunpack17(in, out);
+    break;
+  case 18:
+    internal::__fastunpack18(in, out);
+    break;
+  case 19:
+    internal::__fastunpack19(in, out);
+    break;
+  case 20:
+    internal::__fastunpack20(in, out);
+    break;
+  case 21:
+    internal::__fastunpack21(in, out);
+    break;
+  case 22:
+    internal::__fastunpack22(in, out);
+    break;
+  case 23:
+    internal::__fastunpack23(in, out);
+    break;
+  case 24:
+    internal::__fastunpack24(in, out);
+    break;
+  case 25:
+    internal::__fastunpack25(in, out);
+    break;
+  case 26:
+    internal::__fastunpack26(in, out);
+    break;
+  case 27:
+    internal::__fastunpack27(in, out);
+    break;
+  case 28:
+    internal::__fastunpack28(in, out);
+    break;
+  case 29:
+    internal::__fastunpack29(in, out);
+    break;
+  case 30:
+    internal::__fastunpack30(in, out);
+    break;
+  case 31:
+    internal::__fastunpack31(in, out);
+    break;
+  case 32:
+    internal::__fastunpack32(in, out);
+    break;
+  case 33:
+    internal::__fastunpack33(in, out);
+    break;
+  case 34:
+    internal::__fastunpack34(in, out);
+    break;
+  case 35:
+    internal::__fastunpack35(in, out);
+    break;
+  case 36:
+    internal::__fastunpack36(in, out);
+    break;
+  case 37:
+    internal::__fastunpack37(in, out);
+    break;
+  case 38:
+    internal::__fastunpack38(in, out);
+    break;
+  case 39:
+    internal::__fastunpack39(in, out);
+    break;
+  case 40:
+    internal::__fastunpack40(in, out);
+    break;
+  case 41:
+    internal::__fastunpack41(in, out);
+    break;
+  case 42:
+    internal::__fastunpack42(in, out);
+    break;
+  case 43:
+    internal::__fastunpack43(in, out);
+    break;
+  case 44:
+    internal::__fastunpack44(in, out);
+    break;
+  case 45:
+    internal::__fastunpack45(in, out);
+    break;
+  case 46:
+    internal::__fastunpack46(in, out);
+    break;
+  case 47:
+    internal::__fastunpack47(in, out);
+    break;
+  case 48:
+    internal::__fastunpack48(in, out);
+    break;
+  case 49:
+    internal::__fastunpack49(in, out);
+    break;
+  case 50:
+    internal::__fastunpack50(in, out);
+    break;
+  case 51:
+    internal::__fastunpack51(in, out);
+    break;
+  case 52:
+    internal::__fastunpack52(in, out);
+    break;
+  case 53:
+    internal::__fastunpack53(in, out);
+    break;
+  case 54:
+    internal::__fastunpack54(in, out);
+    break;
+  case 55:
+    internal::__fastunpack55(in, out);
+    break;
+  case 56:
+    internal::__fastunpack56(in, out);
+    break;
+  case 57:
+    internal::__fastunpack57(in, out);
+    break;
+  case 58:
+    internal::__fastunpack58(in, out);
+    break;
+  case 59:
+    internal::__fastunpack59(in, out);
+    break;
+  case 60:
+    internal::__fastunpack60(in, out);
+    break;
+  case 61:
+    internal::__fastunpack61(in, out);
+    break;
+  case 62:
+    internal::__fastunpack62(in, out);
+    break;
+  case 63:
+    internal::__fastunpack63(in, out);
+    break;
+  case 64:
+    internal::__fastunpack64(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+
+	for (uint8_t i = 0; i < 4; i++) {
+		internal::fastpack_quarter(in+(i*8), out + (i*bit), bit);
+	}
+}
+
+inline void fastpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	internal::fastpack_half(in, out, bit);
+	internal::fastpack_half(in+16, out + bit, bit);
+}
+
+inline void fastpack(const uint32_t *__restrict in,
+                     uint32_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastpack0(in, out);
+    break;
+  case 1:
+    internal::__fastpack1(in, out);
+    break;
+  case 2:
+    internal::__fastpack2(in, out);
+    break;
+  case 3:
+    internal::__fastpack3(in, out);
+    break;
+  case 4:
+    internal::__fastpack4(in, out);
+    break;
+  case 5:
+    internal::__fastpack5(in, out);
+    break;
+  case 6:
+    internal::__fastpack6(in, out);
+    break;
+  case 7:
+    internal::__fastpack7(in, out);
+    break;
+  case 8:
+    internal::__fastpack8(in, out);
+    break;
+  case 9:
+    internal::__fastpack9(in, out);
+    break;
+  case 10:
+    internal::__fastpack10(in, out);
+    break;
+  case 11:
+    internal::__fastpack11(in, out);
+    break;
+  case 12:
+    internal::__fastpack12(in, out);
+    break;
+  case 13:
+    internal::__fastpack13(in, out);
+    break;
+  case 14:
+    internal::__fastpack14(in, out);
+    break;
+  case 15:
+    internal::__fastpack15(in, out);
+    break;
+  case 16:
+    internal::__fastpack16(in, out);
+    break;
+  case 17:
+    internal::__fastpack17(in, out);
+    break;
+  case 18:
+    internal::__fastpack18(in, out);
+    break;
+  case 19:
+    internal::__fastpack19(in, out);
+    break;
+  case 20:
+    internal::__fastpack20(in, out);
+    break;
+  case 21:
+    internal::__fastpack21(in, out);
+    break;
+  case 22:
+    internal::__fastpack22(in, out);
+    break;
+  case 23:
+    internal::__fastpack23(in, out);
+    break;
+  case 24:
+    internal::__fastpack24(in, out);
+    break;
+  case 25:
+    internal::__fastpack25(in, out);
+    break;
+  case 26:
+    internal::__fastpack26(in, out);
+    break;
+  case 27:
+    internal::__fastpack27(in, out);
+    break;
+  case 28:
+    internal::__fastpack28(in, out);
+    break;
+  case 29:
+    internal::__fastpack29(in, out);
+    break;
+  case 30:
+    internal::__fastpack30(in, out);
+    break;
+  case 31:
+    internal::__fastpack31(in, out);
+    break;
+  case 32:
+    internal::__fastpack32(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(const uint64_t *__restrict in,
+                     uint32_t *__restrict out, const uint32_t bit) {
+  switch (bit) {
+  case 0:
+    internal::__fastpack0(in, out);
+    break;
+  case 1:
+    internal::__fastpack1(in, out);
+    break;
+  case 2:
+    internal::__fastpack2(in, out);
+    break;
+  case 3:
+    internal::__fastpack3(in, out);
+    break;
+  case 4:
+    internal::__fastpack4(in, out);
+    break;
+  case 5:
+    internal::__fastpack5(in, out);
+    break;
+  case 6:
+    internal::__fastpack6(in, out);
+    break;
+  case 7:
+    internal::__fastpack7(in, out);
+    break;
+  case 8:
+    internal::__fastpack8(in, out);
+    break;
+  case 9:
+    internal::__fastpack9(in, out);
+    break;
+  case 10:
+    internal::__fastpack10(in, out);
+    break;
+  case 11:
+    internal::__fastpack11(in, out);
+    break;
+  case 12:
+    internal::__fastpack12(in, out);
+    break;
+  case 13:
+    internal::__fastpack13(in, out);
+    break;
+  case 14:
+    internal::__fastpack14(in, out);
+    break;
+  case 15:
+    internal::__fastpack15(in, out);
+    break;
+  case 16:
+    internal::__fastpack16(in, out);
+    break;
+  case 17:
+    internal::__fastpack17(in, out);
+    break;
+  case 18:
+    internal::__fastpack18(in, out);
+    break;
+  case 19:
+    internal::__fastpack19(in, out);
+    break;
+  case 20:
+    internal::__fastpack20(in, out);
+    break;
+  case 21:
+    internal::__fastpack21(in, out);
+    break;
+  case 22:
+    internal::__fastpack22(in, out);
+    break;
+  case 23:
+    internal::__fastpack23(in, out);
+    break;
+  case 24:
+    internal::__fastpack24(in, out);
+    break;
+  case 25:
+    internal::__fastpack25(in, out);
+    break;
+  case 26:
+    internal::__fastpack26(in, out);
+    break;
+  case 27:
+    internal::__fastpack27(in, out);
+    break;
+  case 28:
+    internal::__fastpack28(in, out);
+    break;
+  case 29:
+    internal::__fastpack29(in, out);
+    break;
+  case 30:
+    internal::__fastpack30(in, out);
+    break;
+  case 31:
+    internal::__fastpack31(in, out);
+    break;
+  case 32:
+    internal::__fastpack32(in, out);
+    break;
+  case 33:
+    internal::__fastpack33(in, out);
+    break;
+  case 34:
+    internal::__fastpack34(in, out);
+    break;
+  case 35:
+    internal::__fastpack35(in, out);
+    break;
+  case 36:
+    internal::__fastpack36(in, out);
+    break;
+  case 37:
+    internal::__fastpack37(in, out);
+    break;
+  case 38:
+    internal::__fastpack38(in, out);
+    break;
+  case 39:
+    internal::__fastpack39(in, out);
+    break;
+  case 40:
+    internal::__fastpack40(in, out);
+    break;
+  case 41:
+    internal::__fastpack41(in, out);
+    break;
+  case 42:
+    internal::__fastpack42(in, out);
+    break;
+  case 43:
+    internal::__fastpack43(in, out);
+    break;
+  case 44:
+    internal::__fastpack44(in, out);
+    break;
+  case 45:
+    internal::__fastpack45(in, out);
+    break;
+  case 46:
+    internal::__fastpack46(in, out);
+    break;
+  case 47:
+    internal::__fastpack47(in, out);
+    break;
+  case 48:
+    internal::__fastpack48(in, out);
+    break;
+  case 49:
+    internal::__fastpack49(in, out);
+    break;
+  case 50:
+    internal::__fastpack50(in, out);
+    break;
+  case 51:
+    internal::__fastpack51(in, out);
+    break;
+  case 52:
+    internal::__fastpack52(in, out);
+    break;
+  case 53:
+    internal::__fastpack53(in, out);
+    break;
+  case 54:
+    internal::__fastpack54(in, out);
+    break;
+  case 55:
+    internal::__fastpack55(in, out);
+    break;
+  case 56:
+    internal::__fastpack56(in, out);
+    break;
+  case 57:
+    internal::__fastpack57(in, out);
+    break;
+  case 58:
+    internal::__fastpack58(in, out);
+    break;
+  case 59:
+    internal::__fastpack59(in, out);
+    break;
+  case 60:
+    internal::__fastpack60(in, out);
+    break;
+  case 61:
+    internal::__fastpack61(in, out);
+    break;
+  case 62:
+    internal::__fastpack62(in, out);
+    break;
+  case 63:
+    internal::__fastpack63(in, out);
+    break;
+  case 64:
+    internal::__fastpack64(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+} // namespace fastpfor_lib
 
 
+// LICENSE_CHANGE_END
 
 
 
@@ -159578,6 +160699,691 @@ private:
 } // namespace duckdb
 
 
+
+#include <functional>
+
+namespace duckdb {
+
+using bitpacking_width_t = uint8_t;
+
+// Note that optimizations in scanning only work if this value is equal to STANDARD_VECTOR_SIZE, however we keep them
+// separated to prevent the code from break on lower vector sizes
+static constexpr const idx_t BITPACKING_WIDTH_GROUP_SIZE = 1024;
+
+class BitpackingPrimitives {
+public:
+	static constexpr const idx_t BITPACKING_ALGORITHM_GROUP_SIZE = 32;
+	static constexpr const idx_t BITPACKING_HEADER_SIZE = sizeof(uint64_t);
+	static constexpr const bool BYTE_ALIGNED = false;
+
+	// Packs a block of BITPACKING_ALGORITHM_GROUP_SIZE values
+	template <class T>
+	inline static void PackBlock(data_ptr_t dst, T *src, bitpacking_width_t width) {
+		return PackGroup<T>(dst, src, width);
+	}
+
+	// Unpacks a block of BITPACKING_ALGORITHM_GROUP_SIZE values
+	template <class T>
+	inline static void UnPackBlock(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
+	                               bool skip_sign_extension = false) {
+		return UnPackGroup<T>(dst, src, width, skip_sign_extension);
+	}
+
+	// Calculates the minimum required number of bits per value that can store all values
+	template <class T>
+	inline static bitpacking_width_t MinimumBitWidth(T *values, idx_t count) {
+		return FindMinimumBitWidth<T, BYTE_ALIGNED>(values, count);
+	}
+
+private:
+	template <class T>
+	static bitpacking_width_t MinimumBitWidth(T min_value, T max_value) {
+		bitpacking_width_t required_bits;
+
+		if (std::is_signed<T>::value) {
+			if (min_value == NumericLimits<T>::Minimum()) {
+				// handle special case of the minimal value, as it cannot be negated like all other values.
+				return sizeof(T) * 8;
+			} else {
+				max_value = MaxValue((T)-min_value, max_value);
+			}
+		}
+
+		if (max_value == 0) {
+			return 0;
+		}
+
+		if (std::is_signed<T>::value) {
+			required_bits = 1;
+		} else {
+			required_bits = 0;
+		}
+
+		while (max_value) {
+			required_bits++;
+			max_value >>= 1;
+		}
+
+		return GetEffectiveWidth<T>(required_bits);
+	}
+
+	template <class T, bool round_to_next_byte = false>
+	static bitpacking_width_t FindMinimumBitWidth(T *values, idx_t count) {
+		T min_value = values[0];
+		T max_value = values[0];
+
+		for (idx_t i = 1; i < count; i++) {
+			if (values[i] > max_value) {
+				max_value = values[i];
+			}
+
+			if (std::is_signed<T>::value) {
+				if (values[i] < min_value) {
+					min_value = values[i];
+				}
+			}
+		}
+
+		bitpacking_width_t calc_width = MinimumBitWidth<T>(std::is_signed<T>::value ? min_value : 0, max_value);
+
+		// Assert results are correct
+#ifdef DEBUG
+		if (calc_width < sizeof(T) * 8 && calc_width != 0) {
+			if (std::is_signed<T>::value) {
+				D_ASSERT((int64_t)max_value <= (int64_t)(1L << (calc_width - 1)) - 1);
+				D_ASSERT((int64_t)min_value >= (int64_t)(-1 * ((1L << (calc_width - 1)) - 1) - 1));
+			} else {
+				D_ASSERT((uint64_t)max_value <= (uint64_t)(1L << (calc_width)) - 1);
+			}
+		}
+#endif
+		if (round_to_next_byte) {
+			return (calc_width / 8 + (calc_width % 8 != 0)) * 8;
+		} else {
+			return calc_width;
+		}
+	}
+
+	template <class T>
+	static void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
+	                        bool skip_sign_extension = false) {
+		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint8_t *)src, (uint8_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint16_t *)src, (uint16_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint32_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint64_t *)dst, (uint32_t)width);
+		} else {
+			throw InternalException("Unsupported type found in bitpacking.");
+		}
+
+		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
+			SignExtend<T>(dst, width);
+		}
+	}
+
+	// Prevent compression at widths that are ineffective
+	template <class T>
+	static bitpacking_width_t GetEffectiveWidth(bitpacking_width_t width) {
+		if (width > 56) {
+			return 64;
+		}
+
+		if (width > 28 && (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value)) {
+			return 32;
+		}
+
+		else if (width > 14 && (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value)) {
+			return 16;
+		}
+
+		return width;
+	}
+
+	// Sign bit extension
+	template <class T, class T_U = typename std::make_unsigned<T>::type>
+	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
+		T const mask = ((T_U)1) << (width - 1);
+		for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) {
+			T value = Load<T>(dst + i * sizeof(T));
+			value = value & ((((T_U)1) << width) - ((T_U)1));
+			T result = (value ^ mask) - mask;
+			Store(result, dst + i * sizeof(T));
+		}
+	}
+
+	template <class T>
+	static void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
+		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint8_t *)values, (uint8_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint16_t *)values, (uint16_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint32_t *)values, (uint32_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint64_t *)values, (uint32_t *)dst, (uint32_t)width);
+		} else {
+			throw InternalException("Unsupported type found in bitpacking.");
+		}
+	}
+};
+
+struct EmptyBitpackingWriter {
+	template <class T>
+	static void Operation(T *values, bool *validity, bitpacking_width_t width, idx_t count, void *data_ptr) {
+	}
+};
+
+template <class T>
+struct BitpackingState {
+public:
+	BitpackingState() : compression_buffer_idx(0), total_size(0), data_ptr(nullptr) {
+	}
+
+	T compression_buffer[BITPACKING_WIDTH_GROUP_SIZE];
+	bool compression_buffer_validity[BITPACKING_WIDTH_GROUP_SIZE];
+	idx_t compression_buffer_idx;
+	idx_t total_size;
+	void *data_ptr;
+
+public:
+	template <class OP>
+	void Flush() {
+		bitpacking_width_t width = BitpackingPrimitives::MinimumBitWidth<T>(compression_buffer, compression_buffer_idx);
+		OP::Operation(compression_buffer, compression_buffer_validity, width, compression_buffer_idx, data_ptr);
+		total_size += (BITPACKING_WIDTH_GROUP_SIZE * width) / 8 + sizeof(bitpacking_width_t);
+		compression_buffer_idx = 0;
+	}
+
+	template <class OP = EmptyBitpackingWriter>
+	void Update(T *data, ValidityMask &validity, idx_t idx) {
+
+		if (validity.RowIsValid(idx)) {
+			compression_buffer_validity[compression_buffer_idx] = true;
+			compression_buffer[compression_buffer_idx++] = data[idx];
+		} else {
+			// We write zero for easy bitwidth analysis of the compression buffer later
+			compression_buffer_validity[compression_buffer_idx] = false;
+			compression_buffer[compression_buffer_idx++] = 0;
+		}
+
+		if (compression_buffer_idx == BITPACKING_WIDTH_GROUP_SIZE) {
+			// Calculate bitpacking width;
+			Flush<OP>();
+		}
+	}
+};
+
+//===--------------------------------------------------------------------===//
+// Analyze
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingAnalyzeState : public AnalyzeState {
+	BitpackingState<T> state;
+};
+
+template <class T>
+unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalType type) {
+	return make_unique<BitpackingAnalyzeState<T>>();
+}
+
+template <class T>
+bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
+	auto &analyze_state = (BitpackingAnalyzeState<T> &)state;
+	VectorData vdata;
+	input.Orrify(count, vdata);
+
+	auto data = (T *)vdata.data;
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = vdata.sel->get_index(i);
+		analyze_state.state.template Update<EmptyBitpackingWriter>(data, vdata.validity, idx);
+	}
+
+	return true;
+}
+
+template <class T>
+idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
+	auto &bitpacking_state = (BitpackingAnalyzeState<T> &)state;
+	bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
+	return bitpacking_state.state.total_size;
+}
+
+//===--------------------------------------------------------------------===//
+// Compress
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingCompressState : public CompressionState {
+public:
+	explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer) : checkpointer(checkpointer) {
+		auto &db = checkpointer.GetDatabase();
+		auto &type = checkpointer.GetType();
+		auto &config = DBConfig::GetConfig(db);
+		function = config.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING, type.InternalType());
+		CreateEmptySegment(checkpointer.GetRowGroup().start);
+
+		state.data_ptr = (void *)this;
+	}
+
+	ColumnDataCheckpointer &checkpointer;
+	CompressionFunction *function;
+	unique_ptr<ColumnSegment> current_segment;
+	unique_ptr<BufferHandle> handle;
+
+	// Ptr to next free spot in segment;
+	data_ptr_t data_ptr;
+	// Ptr to next free spot for storing bitwidths (growing downwards).
+	data_ptr_t width_ptr;
+
+	BitpackingState<T> state;
+
+public:
+	struct BitpackingWriter {
+		template <class VALUE_TYPE>
+		static void Operation(VALUE_TYPE *values, bool *validity, bitpacking_width_t width, idx_t count,
+		                      void *data_ptr) {
+			auto state = (BitpackingCompressState<T> *)data_ptr;
+
+			if (state->RemainingSize() < (width * BITPACKING_WIDTH_GROUP_SIZE) / 8 + sizeof(bitpacking_width_t)) {
+				// Segment is full
+				auto row_start = state->current_segment->start + state->current_segment->count;
+				state->FlushSegment();
+				state->CreateEmptySegment(row_start);
+			}
+
+			for (idx_t i = 0; i < count; i++) {
+				if (validity[i]) {
+					NumericStatistics::Update<T>(state->current_segment->stats, values[i]);
+				}
+			}
+
+			state->WriteValues(values, width, count);
+		}
+	};
+
+	// Space remaining between the width_ptr growing down and data ptr growing up
+	idx_t RemainingSize() {
+		return width_ptr - data_ptr;
+	}
+
+	void CreateEmptySegment(idx_t row_start) {
+		auto &db = checkpointer.GetDatabase();
+		auto &type = checkpointer.GetType();
+		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
+		compressed_segment->function = function;
+		current_segment = move(compressed_segment);
+		auto &buffer_manager = BufferManager::GetBufferManager(db);
+		handle = buffer_manager.Pin(current_segment->block);
+
+		data_ptr = handle->Ptr() + current_segment->GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
+		width_ptr =
+		    handle->Ptr() + current_segment->GetBlockOffset() + Storage::BLOCK_SIZE - sizeof(bitpacking_width_t);
+	}
+
+	void Append(VectorData &vdata, idx_t count) {
+		// TODO Optimization: avoid use of compression buffer if we can compress straight to result vector
+		auto data = (T *)vdata.data;
+
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = vdata.sel->get_index(i);
+			state.template Update<BitpackingCompressState<T>::BitpackingWriter>(data, vdata.validity, idx);
+		}
+	}
+
+	void WriteValues(T *values, bitpacking_width_t width, idx_t count) {
+		// TODO we can optimize this by stopping early if count < BITPACKING_WIDTH_GROUP_SIZE
+		idx_t compress_loops = BITPACKING_WIDTH_GROUP_SIZE / BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+		for (idx_t i = 0; i < compress_loops; i++) {
+			BitpackingPrimitives::PackBlock<T>(
+			    data_ptr, &values[i * BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE], width);
+			data_ptr += (BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE * width) / 8;
+		}
+
+		Store<bitpacking_width_t>(width, width_ptr);
+		width_ptr -= sizeof(bitpacking_width_t);
+
+		current_segment->count += count;
+	}
+
+	void FlushSegment() {
+		auto &state = checkpointer.GetCheckpointState();
+
+		// Compact the segment by moving the widths next to the data.
+		idx_t minimal_widths_offset = AlignValue(data_ptr - handle->node->buffer);
+		idx_t widths_size = handle->node->buffer + Storage::BLOCK_SIZE - width_ptr - 1;
+		idx_t total_segment_size = minimal_widths_offset + widths_size;
+		memmove(handle->node->buffer + minimal_widths_offset, width_ptr + 1, widths_size);
+
+		// Store the offset of the first width (which is at the highest address).
+		Store<idx_t>(minimal_widths_offset + widths_size - 1, handle->node->buffer);
+		handle.reset();
+
+		state.FlushSegment(move(current_segment), total_segment_size);
+	}
+
+	void Finalize() {
+		state.template Flush<BitpackingCompressState<T>::BitpackingWriter>();
+		FlushSegment();
+		current_segment.reset();
+	}
+};
+
+template <class T>
+unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &checkpointer,
+                                                       unique_ptr<AnalyzeState> state) {
+	return make_unique<BitpackingCompressState<T>>(checkpointer);
+}
+
+template <class T>
+void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
+	auto &state = (BitpackingCompressState<T> &)state_p;
+	VectorData vdata;
+	scan_vector.Orrify(count, vdata);
+	state.Append(vdata, count);
+}
+
+template <class T>
+void BitpackingFinalizeCompress(CompressionState &state_p) {
+	auto &state = (BitpackingCompressState<T> &)state_p;
+	state.Finalize();
+}
+
+//===--------------------------------------------------------------------===//
+// Scan
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingScanState : public SegmentScanState {
+public:
+	explicit BitpackingScanState(ColumnSegment &segment) {
+		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
+		handle = buffer_manager.Pin(segment.block);
+
+		current_width_group_ptr =
+		    handle->node->buffer + segment.GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
+
+		// load offset to bitpacking widths pointer
+		auto bitpacking_widths_offset = Load<idx_t>(handle->node->buffer + segment.GetBlockOffset());
+		bitpacking_width_ptr = handle->node->buffer + segment.GetBlockOffset() + bitpacking_widths_offset;
+
+		// load the bitwidth of the first vector
+		LoadCurrentBitWidth();
+	}
+
+	unique_ptr<BufferHandle> handle;
+
+	void (*decompress_function)(data_ptr_t, data_ptr_t, bitpacking_width_t, bool skip_sign_extension);
+	T decompression_buffer[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
+
+	idx_t position_in_group = 0;
+	data_ptr_t current_width_group_ptr;
+	data_ptr_t bitpacking_width_ptr;
+	bitpacking_width_t current_width;
+
+public:
+	void LoadCurrentBitWidth() {
+		D_ASSERT(bitpacking_width_ptr > handle->node->buffer &&
+		         bitpacking_width_ptr < handle->node->buffer + Storage::BLOCK_SIZE);
+		current_width = Load<bitpacking_width_t>(bitpacking_width_ptr);
+		LoadDecompressFunction();
+	}
+
+	void Skip(ColumnSegment &segment, idx_t skip_count) {
+		while (skip_count > 0) {
+			if (position_in_group + skip_count < BITPACKING_WIDTH_GROUP_SIZE) {
+				// We're not leaving this bitpacking group, we can perform all skips.
+				position_in_group += skip_count;
+				break;
+			} else {
+				// The skip crosses the current bitpacking group, we skip the remainder of this group.
+				auto skipping = BITPACKING_WIDTH_GROUP_SIZE - position_in_group;
+				position_in_group = 0;
+				current_width_group_ptr += (current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
+
+				// Update width pointer and load new width
+				bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+				LoadCurrentBitWidth();
+
+				skip_count -= skipping;
+			}
+		}
+	}
+
+	void LoadDecompressFunction() {
+		decompress_function = &BitpackingPrimitives::UnPackBlock<T>;
+	}
+};
+
+template <class T>
+unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
+	auto result = make_unique<BitpackingScanState<T>>(segment);
+	return move(result);
+}
+
+//===--------------------------------------------------------------------===//
+// Scan base data
+//===--------------------------------------------------------------------===//
+template <class T>
+void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
+                           idx_t result_offset) {
+	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
+
+	T *result_data = FlatVector::GetData<T>(result);
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+
+	// Fast path for when no compression was used, we can do a single memcopy
+	if (STANDARD_VECTOR_SIZE == BITPACKING_WIDTH_GROUP_SIZE) {
+		if (scan_state.current_width == sizeof(T) * 8 && scan_count <= BITPACKING_WIDTH_GROUP_SIZE &&
+		    scan_state.position_in_group == 0) {
+
+			memcpy(result_data + result_offset, scan_state.current_width_group_ptr, scan_count * sizeof(T));
+			scan_state.current_width_group_ptr += scan_count * sizeof(T);
+			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+			scan_state.LoadCurrentBitWidth();
+			return;
+		}
+	}
+
+	// Determine if we can skip sign extension during compression
+	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
+	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
+
+	idx_t scanned = 0;
+
+	while (scanned < scan_count) {
+		// Exhausted this width group, move pointers to next group and load bitwidth for next group.
+		if (scan_state.position_in_group >= BITPACKING_WIDTH_GROUP_SIZE) {
+			scan_state.position_in_group = 0;
+			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+			scan_state.current_width_group_ptr += (scan_state.current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
+			scan_state.LoadCurrentBitWidth();
+		}
+
+		idx_t offset_in_compression_group =
+		    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+
+		idx_t to_scan = MinValue<idx_t>(scan_count - scanned, BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE -
+		                                                          offset_in_compression_group);
+
+		// Calculate start of compression algorithm group
+		data_ptr_t current_position_ptr =
+		    scan_state.current_width_group_ptr + scan_state.position_in_group * scan_state.current_width / 8;
+		data_ptr_t decompression_group_start_pointer =
+		    current_position_ptr - offset_in_compression_group * scan_state.current_width / 8;
+
+		T *current_result_ptr = result_data + result_offset + scanned;
+
+		if (to_scan == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE && offset_in_compression_group == 0) {
+			// Decompress directly into result vector
+			scan_state.decompress_function((data_ptr_t)current_result_ptr, decompression_group_start_pointer,
+			                               scan_state.current_width, skip_sign_extend);
+		} else {
+			// Decompress compression algorithm to buffer
+			scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer,
+			                               decompression_group_start_pointer, scan_state.current_width,
+			                               skip_sign_extend);
+
+			memcpy(current_result_ptr, scan_state.decompression_buffer + offset_in_compression_group,
+			       to_scan * sizeof(T));
+		}
+
+		scanned += to_scan;
+		scan_state.position_in_group += to_scan;
+	}
+}
+
+template <class T>
+void BitpackingScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
+	BitpackingScanPartial<T>(segment, state, scan_count, result, 0);
+}
+
+//===--------------------------------------------------------------------===//
+// Fetch
+//===--------------------------------------------------------------------===//
+template <class T>
+void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
+                        idx_t result_idx) {
+	BitpackingScanState<T> scan_state(segment);
+	scan_state.Skip(segment, row_id);
+	auto result_data = FlatVector::GetData<T>(result);
+	T *current_result_ptr = result_data + result_idx;
+
+	// TODO clean up, is reused in partialscan
+	idx_t offset_in_compression_group =
+	    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+
+	data_ptr_t decompression_group_start_pointer =
+	    scan_state.current_width_group_ptr +
+	    (scan_state.position_in_group - offset_in_compression_group) * scan_state.current_width / 8;
+
+	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
+	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
+
+	scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer, decompression_group_start_pointer,
+	                               scan_state.current_width, skip_sign_extend);
+
+	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
+}
+template <class T>
+void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
+	scan_state.Skip(segment, skip_count);
+}
+
+//===--------------------------------------------------------------------===//
+// Get Function
+//===--------------------------------------------------------------------===//
+template <class T>
+CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_BITPACKING, data_type, BitpackingInitAnalyze<T>,
+	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>, BitpackingInitCompression<T>,
+	                           BitpackingCompress<T>, BitpackingFinalizeCompress<T>, BitpackingInitScan<T>,
+	                           BitpackingScan<T>, BitpackingScanPartial<T>, BitpackingFetchRow<T>, BitpackingSkip<T>);
+}
+
+CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::INT8:
+		return GetBitpackingFunction<int8_t>(type);
+	case PhysicalType::INT16:
+		return GetBitpackingFunction<int16_t>(type);
+	case PhysicalType::INT32:
+		return GetBitpackingFunction<int32_t>(type);
+	case PhysicalType::INT64:
+		return GetBitpackingFunction<int64_t>(type);
+	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+		return GetBitpackingFunction<uint8_t>(type);
+	case PhysicalType::UINT16:
+		return GetBitpackingFunction<uint16_t>(type);
+	case PhysicalType::UINT32:
+		return GetBitpackingFunction<uint32_t>(type);
+	case PhysicalType::UINT64:
+		return GetBitpackingFunction<uint64_t>(type);
+	default:
+		throw InternalException("Unsupported type for Bitpacking");
+	}
+}
+
+bool BitpackingFun::TypeIsSupported(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+	case PhysicalType::INT16:
+	case PhysicalType::INT32:
+	case PhysicalType::INT64:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
+		return true;
+	default:
+		return false;
+	}
+}
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/segment/uncompressed.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+
+struct UncompressedFunctions {
+	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
+	                                                    unique_ptr<AnalyzeState> state);
+	static void Compress(CompressionState &state_p, Vector &data, idx_t count);
+	static void FinalizeCompress(CompressionState &state_p);
+	static void EmptySkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+	}
+};
+
+struct FixedSizeUncompressed {
+	static CompressionFunction GetFunction(PhysicalType data_type);
+};
+
+struct ValidityUncompressed {
+public:
+	static CompressionFunction GetFunction(PhysicalType data_type);
+
+public:
+	static const validity_t LOWER_MASKS[65];
+	static const validity_t UPPER_MASKS[65];
+};
+
+struct StringUncompressed {
+public:
+	static CompressionFunction GetFunction(PhysicalType data_type);
+
+public:
+	//! The max string size that is allowed within a block. Strings bigger than this will be labeled as a BIG STRING and
+	//! offloaded to the overflow blocks.
+	static constexpr uint16_t STRING_BLOCK_LIMIT = 4096;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
+
+
+
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -207501,6 +209307,1299 @@ void sdfree(void *ptr) { free(ptr); }
 // LICENSE_CHANGE_END
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
+
+
+
+#include <cstdint>
+#include <type_traits>
+
+namespace duckdb_fastpforlib {
+namespace internal {
+
+// Used for uint8_t, uint16_t and uint32_t
+template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) < TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict in,
+                                                                           TYPE *__restrict out) {
+	*out = ((*in) >> SHR) % (1 << DELTA);
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) >= TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict &in,
+                                                                            TYPE *__restrict out) {
+	*out = (*in) >> SHR;
+	++in;
+
+	static const TYPE NEXT_SHR = SHR + DELTA - TYPE_SIZE;
+	*out |= ((*in) % (1U << NEXT_SHR)) << (TYPE_SIZE - SHR);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) < 32>::type unpack_single_out(const uint32_t *__restrict in,
+                                                                    uint64_t *__restrict out) {
+	*out = ((static_cast<uint64_t>(*in)) >> SHR) % (1ULL << DELTA);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 32 && (DELTA + SHR) < 64>::type
+unpack_single_out(const uint32_t *__restrict &in, uint64_t *__restrict out) {
+	*out = static_cast<uint64_t>(*in) >> SHR;
+	++in;
+	if (DELTA + SHR > 32) {
+		static const uint8_t NEXT_SHR = SHR + DELTA - 32;
+		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (32 - SHR);
+	}
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 64>::type unpack_single_out(const uint32_t *__restrict &in,
+                                                                     uint64_t *__restrict out) {
+	*out = static_cast<uint64_t>(*in) >> SHR;
+	++in;
+
+	*out |= static_cast<uint64_t>(*in) << (32 - SHR);
+	++in;
+
+	if (DELTA + SHR > 64) {
+		static const uint8_t NEXT_SHR = DELTA + SHR - 64;
+		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (64 - SHR);
+	}
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+    typename std::enable_if < DELTA + SHL<TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict out) {
+	if (SHL == 0) {
+		*out = in & MASK;
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<DELTA + SHL >= TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict &out) {
+	*out |= in << SHL;
+	++out;
+
+	if (DELTA + SHL > TYPE_SIZE) {
+		*out = (in & MASK) >> (TYPE_SIZE - SHL);
+	}
+}
+
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+    typename std::enable_if < DELTA + SHL<32>::type pack_single_in64(const uint64_t in, uint32_t *__restrict out) {
+	if (SHL == 0) {
+		*out = static_cast<uint32_t>(in & MASK);
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+        typename std::enable_if < DELTA + SHL >= 32 &&
+    DELTA + SHL<64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
+	if (SHL == 0) {
+		*out = static_cast<uint32_t>(in & MASK);
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+
+	++out;
+
+	if (DELTA + SHL > 32) {
+		*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+	}
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+typename std::enable_if<DELTA + SHL >= 64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
+	*out |= in << SHL;
+	++out;
+
+	*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+	++out;
+
+	if (DELTA + SHL > 64) {
+		*out = (in & MASK) >> (64 - SHL);
+	}
+}
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller8 {
+	static void Unpack(const uint8_t *__restrict &in, uint8_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 8>(in, out + OINDEX);
+
+		Unroller8<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		pack_single_in<uint8_t, DELTA, (DELTA * OINDEX) % 8, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller8<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+};\
+template <uint16_t DELTA>
+struct Unroller8<DELTA, 7> {
+	enum { SHIFT = (DELTA * 7) % 8 };
+
+	static void Unpack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		out[7] = (*in) >> SHIFT;
+	}
+
+	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		*out |= (in[7] << SHIFT);
+	}
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller16 {
+	static void Unpack(const uint16_t *__restrict &in, uint16_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 16>(in, out + OINDEX);
+
+		Unroller16<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		pack_single_in<uint16_t, DELTA, (DELTA * OINDEX) % 16, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller16<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+};
+
+template <uint16_t DELTA>
+struct Unroller16<DELTA, 15> {
+	enum { SHIFT = (DELTA * 15) % 16 };
+
+	static void Unpack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		out[15] = (*in) >> SHIFT;
+	}
+
+	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		*out |= (in[15] << SHIFT);
+	}
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller {
+	static void Unpack(const uint32_t *__restrict &in, uint32_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Unpack(const uint32_t *__restrict &in, uint64_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		pack_single_in<uint32_t, DELTA, (DELTA * OINDEX) % 32, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
+		pack_single_in64<DELTA, (DELTA * OINDEX) % 32, (1ULL << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+};
+
+template <uint16_t DELTA>
+struct Unroller<DELTA, 31> {
+	enum { SHIFT = (DELTA * 31) % 32 };
+
+	static void Unpack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		out[31] = (*in) >> SHIFT;
+	}
+
+	static void Unpack(const uint32_t *__restrict in, uint64_t *__restrict out) {
+		out[31] = (*in) >> SHIFT;
+		if (DELTA > 32) {
+			++in;
+			out[31] |= static_cast<uint64_t>(*in) << (32 - SHIFT);
+		}
+	}
+
+	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		*out |= (in[31] << SHIFT);
+	}
+
+	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
+		*out |= (in[31] << SHIFT);
+		if (DELTA > 32) {
+			++out;
+			*out = static_cast<uint32_t>(in[31] >> (32 - SHIFT));
+		}
+	}
+};
+
+// Special cases
+void __fastunpack0(const uint8_t *__restrict, uint8_t *__restrict out) {
+	for (uint8_t i = 0; i < 8; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint16_t *__restrict, uint16_t *__restrict out) {
+	for (uint16_t i = 0; i < 16; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t *__restrict, uint32_t *__restrict out) {
+	for (uint32_t i = 0; i < 32; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t *__restrict, uint64_t *__restrict out) {
+	for (uint32_t i = 0; i < 32; ++i)
+		*(out++) = 0;
+}
+
+void __fastpack0(const uint8_t *__restrict, uint8_t *__restrict) {
+}
+void __fastpack0(const uint16_t *__restrict, uint16_t *__restrict) {
+}
+void __fastpack0(const uint32_t *__restrict, uint32_t *__restrict) {
+}
+void __fastpack0(const uint64_t *__restrict, uint32_t *__restrict) {
+}
+
+// fastunpack for 8 bits
+void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (uint8_t outer = 0; outer < 4; ++outer) {
+		for (uint8_t inwordpointer = 0; inwordpointer < 8; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (int k = 0; k < 8; ++k)
+		out[k] = in[k];
+}
+
+
+// fastunpack for 16 bits
+void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (uint16_t outer = 0; outer < 4; ++outer) {
+		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (uint16_t outer = 0; outer < 8; ++outer) {
+		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 8)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		++in;
+	}
+}
+
+void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (int k = 0; k < 16; ++k)
+		out[k] = in[k];
+}
+
+// fastunpack for 32 bits
+void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 4; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 8; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		++in;
+	}
+}
+
+void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 16; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
+		++in;
+	}
+}
+
+void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+// fastupack for 64 bits
+void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 4; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 8; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8) {
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		}
+		++in;
+	}
+}
+
+void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 16; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
+		++in;
+	}
+}
+
+void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<33>::Unpack(in, out);
+}
+
+void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<34>::Unpack(in, out);
+}
+
+void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<35>::Unpack(in, out);
+}
+
+void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<36>::Unpack(in, out);
+}
+
+void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<37>::Unpack(in, out);
+}
+
+void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<38>::Unpack(in, out);
+}
+
+void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<39>::Unpack(in, out);
+}
+
+void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<40>::Unpack(in, out);
+}
+
+void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<41>::Unpack(in, out);
+}
+
+void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<42>::Unpack(in, out);
+}
+
+void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<43>::Unpack(in, out);
+}
+
+void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<44>::Unpack(in, out);
+}
+
+void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<45>::Unpack(in, out);
+}
+
+void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<46>::Unpack(in, out);
+}
+
+void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<47>::Unpack(in, out);
+}
+
+void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<48>::Unpack(in, out);
+}
+
+void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<49>::Unpack(in, out);
+}
+
+void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<50>::Unpack(in, out);
+}
+
+void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<51>::Unpack(in, out);
+}
+
+void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<52>::Unpack(in, out);
+}
+
+void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<53>::Unpack(in, out);
+}
+
+void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<54>::Unpack(in, out);
+}
+
+void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<55>::Unpack(in, out);
+}
+
+void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<56>::Unpack(in, out);
+}
+
+void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<57>::Unpack(in, out);
+}
+
+void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<58>::Unpack(in, out);
+}
+
+void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<59>::Unpack(in, out);
+}
+
+void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<60>::Unpack(in, out);
+}
+
+void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<61>::Unpack(in, out);
+}
+
+void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<62>::Unpack(in, out);
+}
+
+void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<63>::Unpack(in, out);
+}
+
+void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (int k = 0; k < 32; ++k) {
+		out[k] = in[k * 2];
+		out[k] |= static_cast<uint64_t>(in[k * 2 + 1]) << 32;
+	}
+}
+
+// fastpack for 8 bits
+
+void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (int k = 0; k < 8; ++k)
+		out[k] = in[k];
+}
+
+// fastpack for 16 bits
+
+void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (int k = 0; k < 16; ++k)
+		out[k] = in[k];
+}
+
+
+// fastpack for 32 bits
+
+void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+// fastpack for 64 bits
+
+void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k) {
+		out[k] = static_cast<uint32_t>(in[k]);
+	}
+}
+
+void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<33>::Pack(in, out);
+}
+
+void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<34>::Pack(in, out);
+}
+
+void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<35>::Pack(in, out);
+}
+
+void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<36>::Pack(in, out);
+}
+
+void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<37>::Pack(in, out);
+}
+
+void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<38>::Pack(in, out);
+}
+
+void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<39>::Pack(in, out);
+}
+
+void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<40>::Pack(in, out);
+}
+
+void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<41>::Pack(in, out);
+}
+
+void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<42>::Pack(in, out);
+}
+
+void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<43>::Pack(in, out);
+}
+
+void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<44>::Pack(in, out);
+}
+
+void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<45>::Pack(in, out);
+}
+
+void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<46>::Pack(in, out);
+}
+
+void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<47>::Pack(in, out);
+}
+
+void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<48>::Pack(in, out);
+}
+
+void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<49>::Pack(in, out);
+}
+
+void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<50>::Pack(in, out);
+}
+
+void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<51>::Pack(in, out);
+}
+
+void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<52>::Pack(in, out);
+}
+
+void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<53>::Pack(in, out);
+}
+
+void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<54>::Pack(in, out);
+}
+
+void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<55>::Pack(in, out);
+}
+
+void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<56>::Pack(in, out);
+}
+
+void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<57>::Pack(in, out);
+}
+
+void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<58>::Pack(in, out);
+}
+
+void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<59>::Pack(in, out);
+}
+
+void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<60>::Pack(in, out);
+}
+
+void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<61>::Pack(in, out);
+}
+
+void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<62>::Pack(in, out);
+}
+
+void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<63>::Pack(in, out);
+}
+
+void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	for (int i = 0; i < 32; ++i) {
+		out[2 * i] = static_cast<uint32_t>(in[i]);
+		out[2 * i + 1] = in[i] >> 32;
+	}
+}
+} // namespace internal
+} // namespace duckdb_fastpforlib
+
+
+// LICENSE_CHANGE_END
+
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
 // See the end of this file for a list
@@ -257634,4 +260733,199 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 
+
+### THIRD PARTY LICENSE #10 ###
+
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
+
 */