duckdb 0.3.2-dev396.0 → 0.3.2-dev481.0

package/src/duckdb.cpp

@@ -29651,8 +29651,7 @@ void Deserializer::ReadStringVector(vector<string> &list) {
 namespace duckdb {
 
 struct SortLayout;
-struct SortedBlock;
-struct SortedData;
+struct SBScanState;
 
 using ValidityBytes = RowLayout::ValidityBytes;
 
@@ -29662,14 +29661,14 @@ public:
 	static bool TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout);
 	//! Compares the tuples that a being read from in the 'left' and 'right blocks during merge sort
 	//! (only in case we cannot simply 'memcmp' - if there are blob columns)
-	static int CompareTuple(const SortedBlock &left, const SortedBlock &right, const data_ptr_t &l_ptr,
+	static int CompareTuple(const SBScanState &left, const SBScanState &right, const data_ptr_t &l_ptr,
 	                        const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort);
 	//! Compare two blob values
 	static int CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type);
 
 private:
 	//! Compares two blob values that were initially tied by their prefix
-	static int BreakBlobTie(const idx_t &tie_col, const SortedData &left, const SortedData &right,
+	static int BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
 	                        const SortLayout &sort_layout, const bool &external);
 	//! Compare two fixed-size values
 	template <class T>
@@ -30423,59 +30422,36 @@ struct RowDataBlock;
 struct SortLayout;
 struct GlobalSortState;
 
+enum class SortedDataType { BLOB, PAYLOAD };
+
 //! Object that holds sorted rows, and an accompanying heap if there are blobs
 struct SortedData {
 public:
-	SortedData(const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
+	SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
 	//! Number of rows that this object holds
 	idx_t Count();
-	//! Pin the current block so it can be read
-	void Pin();
-	//! Pointer to the row that is currently being read from
-	data_ptr_t DataPtr() const;
-	//! Pointer to the heap row that corresponds to the current row
-	data_ptr_t HeapPtr() const;
-	//! Advance one row
-	void Advance(const bool &adv);
 	//! Initialize new block to write to
 	void CreateBlock();
-	//! Reset read indices to the given indices
-	void ResetIndices(idx_t block_idx_to, idx_t entry_idx_to);
 	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t start_entry_index, idx_t end_block_index,
-	                                   idx_t end_entry_index);
+	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t end_block_index, idx_t end_entry_index);
 	//! Unswizzles all
 	void Unswizzle();
 
 public:
+	const SortedDataType type;
 	//! Layout of this data
 	const RowLayout layout;
 	//! Data and heap blocks
 	vector<RowDataBlock> data_blocks;
 	vector<RowDataBlock> heap_blocks;
-	//! Buffer handles to the data being currently read
-	unique_ptr<BufferHandle> data_handle;
-	unique_ptr<BufferHandle> heap_handle;
-	//! Read indices
-	idx_t block_idx;
-	idx_t entry_idx;
 	//! Whether the pointers in this sorted data are swizzled
 	bool swizzled;
 
-private:
-	//! Pin fixed-size row data
-	void PinData();
-	//! Pin the accompanying heap data (if any)
-	void PinHeap();
-
 private:
 	//! The buffer manager
 	BufferManager &buffer_manager;
 	//! The global state
 	GlobalSortState &state;
-	//! Pointers into the buffers being currently read
-	data_ptr_t data_ptr;
-	data_ptr_t heap_ptr;
 };
 
 //! Block that holds sorted rows: radix, blob and payload data
@@ -30484,21 +30460,17 @@ public:
 	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
 	//! Number of rows that this object holds
 	idx_t Count() const;
-	//! The remaining number of rows to be read from this object
-	idx_t Remaining() const;
 	//! Initialize this block to write data to
 	void InitializeWrite();
 	//! Init new block to write to
 	void CreateBlock();
-	//! Pins radix block with given index
-	void PinRadix(idx_t pin_block_idx);
 	//! Fill this sorted block by appending the blocks held by a vector of sorted blocks
 	void AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks);
 	//! Locate the block and entry index of a row in this block,
 	//! given an index between 0 and the total number of rows in this block
 	void GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index);
 	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end);
+	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end, idx_t &entry_idx);
 
 	//! Size (in bytes) of the heap of this block
 	idx_t HeapSize() const;
@@ -30508,25 +30480,59 @@ public:
 public:
 	//! Radix/memcmp sortable data
 	vector<RowDataBlock> radix_sorting_data;
-	unique_ptr<BufferHandle> radix_handle;
-	idx_t block_idx;
-	idx_t entry_idx;
 	//! Variable sized sorting data
 	unique_ptr<SortedData> blob_sorting_data;
 	//! Payload data
 	unique_ptr<SortedData> payload_data;
 
 private:
-	//! Buffer manager, and sorting layout constants
+	//! Buffer manager, global state, and sorting layout constants
 	BufferManager &buffer_manager;
 	GlobalSortState &state;
 	const SortLayout &sort_layout;
 	const RowLayout &payload_layout;
 };
 
-struct SortedDataScanner {
+//! State used to scan a SortedBlock e.g. during merge sort
+struct SBScanState {
 public:
-	SortedDataScanner(SortedData &sorted_data, GlobalSortState &global_sort_state);
+	SBScanState(BufferManager &buffer_manager, GlobalSortState &state);
+
+	void PinRadix(idx_t block_idx_to);
+	void PinData(SortedData &sd);
+
+	data_ptr_t RadixPtr() const;
+	data_ptr_t DataPtr(SortedData &sd) const;
+	data_ptr_t HeapPtr(SortedData &sd) const;
+	data_ptr_t BaseHeapPtr(SortedData &sd) const;
+
+	idx_t Remaining() const;
+
+	void SetIndices(idx_t block_idx_to, idx_t entry_idx_to);
+
+public:
+	BufferManager &buffer_manager;
+	const SortLayout &sort_layout;
+	GlobalSortState &state;
+
+	SortedBlock *sb;
+
+	idx_t block_idx;
+	idx_t entry_idx;
+
+	unique_ptr<BufferHandle> radix_handle = nullptr;
+
+	unique_ptr<BufferHandle> blob_sorting_data_handle = nullptr;
+	unique_ptr<BufferHandle> blob_sorting_heap_handle = nullptr;
+
+	unique_ptr<BufferHandle> payload_data_handle = nullptr;
+	unique_ptr<BufferHandle> payload_heap_handle = nullptr;
+};
+
+//! Used to scan the data into DataChunks after sorting
+struct PayloadScanner {
+public:
+	PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state);
 
 	//! Scans the next data chunk from the sorted data
 	void Scan(DataChunk &chunk);
@@ -30534,6 +30540,8 @@ public:
 private:
 	//! The sorted data being scanned
 	SortedData &sorted_data;
+	//! Read state
+	SBScanState read_state;
 	//! The total count of sorted_data
 	const idx_t total_count;
 	//! The global sort state
@@ -30685,13 +30693,29 @@ public:
 	//! Finds and merges partitions until the current cascaded merge round is finished
 	void PerformInMergeRound();
 
+private:
+	//! The global sorting state
+	GlobalSortState &state;
+	//! The sorting and payload layouts
+	BufferManager &buffer_manager;
+	const SortLayout &sort_layout;
+
+	//! The left and right reader
+	unique_ptr<SBScanState> left;
+	unique_ptr<SBScanState> right;
+
+	//! Input and output blocks
+	unique_ptr<SortedBlock> left_input;
+	unique_ptr<SortedBlock> right_input;
+	SortedBlock *result;
+
 private:
 	//! Computes the left and right block that will be merged next (Merge Path partition)
 	void GetNextPartition();
 	//! Finds the boundary of the next partition using binary search
-	void GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
+	void GetIntersection(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
 	//! Compare values within SortedBlocks using a global index
-	int CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const idx_t l_idx, const idx_t r_idx);
+	int CompareUsingGlobalIndex(SBScanState &l, SBScanState &r, const idx_t l_idx, const idx_t r_idx);
 
 	//! Finds the next partition and merges it
 	void MergePartition();
@@ -30703,7 +30727,7 @@ private:
 	void MergeRadix(const idx_t &count, const bool left_smaller[]);
 	//! Merges SortedData according to the 'left_smaller' array
 	void MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
-	               const bool left_smaller[], idx_t next_entry_sizes[]);
+	               const bool left_smaller[], idx_t next_entry_sizes[], bool reset_indices);
 	//! Merges constant size rows according to the 'left_smaller' array
 	void MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr, idx_t &r_entry_idx,
 	               const idx_t &r_count, RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size,
@@ -30717,18 +30741,6 @@ private:
 	                idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock *target_data_block,
 	                data_ptr_t &target_data_ptr, RowDataBlock *target_heap_block, BufferHandle &target_heap_handle,
 	                data_ptr_t &target_heap_ptr, idx_t &copied, const idx_t &count);
-
-private:
-	//! The global sorting state
-	GlobalSortState &state;
-	//! The sorting and payload layouts
-	BufferManager &buffer_manager;
-	const SortLayout &sort_layout;
-
-	//! The left, right and result blocks of the current partition
-	unique_ptr<SortedBlock> left_block;
-	unique_ptr<SortedBlock> right_block;
-	SortedBlock *result;
 };
 
 } // namespace duckdb
@@ -30757,7 +30769,7 @@ bool Comparators::TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr,
 	return true;
 }
 
-int Comparators::CompareTuple(const SortedBlock &left, const SortedBlock &right, const data_ptr_t &l_ptr,
+int Comparators::CompareTuple(const SBScanState &left, const SBScanState &right, const data_ptr_t &l_ptr,
                               const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort) {
 	// Compare the sorting columns one by one
 	int comp_res = 0;
@@ -30766,8 +30778,7 @@ int Comparators::CompareTuple(const SortedBlock &left, const SortedBlock &right,
 	for (idx_t col_idx = 0; col_idx < sort_layout.column_count; col_idx++) {
 		comp_res = FastMemcmp(l_ptr_offset, r_ptr_offset, sort_layout.column_sizes[col_idx]);
 		if (comp_res == 0 && !sort_layout.constant_size[col_idx]) {
-			comp_res =
-			    BreakBlobTie(col_idx, *left.blob_sorting_data, *right.blob_sorting_data, sort_layout, external_sort);
+			comp_res = BreakBlobTie(col_idx, left, right, sort_layout, external_sort);
 		}
 		if (comp_res != 0) {
 			break;
@@ -30793,11 +30804,11 @@ int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, cons
 	}
 }
 
-int Comparators::BreakBlobTie(const idx_t &tie_col, const SortedData &left, const SortedData &right,
+int Comparators::BreakBlobTie(const idx_t &tie_col, const SBScanState &left, const SBScanState &right,
                               const SortLayout &sort_layout, const bool &external) {
 	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	data_ptr_t l_data_ptr = left.DataPtr();
-	data_ptr_t r_data_ptr = right.DataPtr();
+	data_ptr_t l_data_ptr = left.DataPtr(*left.sb->blob_sorting_data);
+	data_ptr_t r_data_ptr = right.DataPtr(*right.sb->blob_sorting_data);
 	if (!TieIsBreakable(col_idx, l_data_ptr, sort_layout.blob_layout)) {
 		// Quick check to see if ties can be broken
 		return 0;
@@ -30808,12 +30819,12 @@ int Comparators::BreakBlobTie(const idx_t &tie_col, const SortedData &left, cons
 	r_data_ptr += tie_col_offset;
 	// Do the comparison
 	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
-	const auto &type = left.layout.GetTypes()[col_idx];
+	const auto &type = sort_layout.blob_layout.GetTypes()[col_idx];
 	int result;
 	if (external) {
 		// Store heap pointers
-		data_ptr_t l_heap_ptr = left.HeapPtr();
-		data_ptr_t r_heap_ptr = right.HeapPtr();
+		data_ptr_t l_heap_ptr = left.HeapPtr(*left.sb->blob_sorting_data);
+		data_ptr_t r_heap_ptr = right.HeapPtr(*right.sb->blob_sorting_data);
 		// Unswizzle offset to pointer
 		UnswizzleSingleValue(l_data_ptr, l_heap_ptr, type);
 		UnswizzleSingleValue(r_data_ptr, r_heap_ptr, type);
@@ -31114,21 +31125,23 @@ void MergeSorter::PerformInMergeRound() {
 }
 
 void MergeSorter::MergePartition() {
-	auto &left = *left_block;
-	auto &right = *right_block;
+	auto &left_block = *left->sb;
+	auto &right_block = *right->sb;
 #ifdef DEBUG
-	D_ASSERT(left.radix_sorting_data.size() == left.payload_data->data_blocks.size());
-	D_ASSERT(right.radix_sorting_data.size() == right.payload_data->data_blocks.size());
+	D_ASSERT(left_block.radix_sorting_data.size() == left_block.payload_data->data_blocks.size());
+	D_ASSERT(right_block.radix_sorting_data.size() == right_block.payload_data->data_blocks.size());
 	if (!state.payload_layout.AllConstant() && state.external) {
-		D_ASSERT(left.payload_data->data_blocks.size() == left.payload_data->heap_blocks.size());
-		D_ASSERT(right.payload_data->data_blocks.size() == right.payload_data->heap_blocks.size());
+		D_ASSERT(left_block.payload_data->data_blocks.size() == left_block.payload_data->heap_blocks.size());
+		D_ASSERT(right_block.payload_data->data_blocks.size() == right_block.payload_data->heap_blocks.size());
 	}
 	if (!sort_layout.all_constant) {
-		D_ASSERT(left.radix_sorting_data.size() == left.blob_sorting_data->data_blocks.size());
-		D_ASSERT(right.radix_sorting_data.size() == right.blob_sorting_data->data_blocks.size());
+		D_ASSERT(left_block.radix_sorting_data.size() == left_block.blob_sorting_data->data_blocks.size());
+		D_ASSERT(right_block.radix_sorting_data.size() == right_block.blob_sorting_data->data_blocks.size());
 		if (state.external) {
-			D_ASSERT(left.blob_sorting_data->data_blocks.size() == left.blob_sorting_data->heap_blocks.size());
-			D_ASSERT(right.blob_sorting_data->data_blocks.size() == right.blob_sorting_data->heap_blocks.size());
+			D_ASSERT(left_block.blob_sorting_data->data_blocks.size() ==
+			         left_block.blob_sorting_data->heap_blocks.size());
+			D_ASSERT(right_block.blob_sorting_data->data_blocks.size() ==
+			         right_block.blob_sorting_data->heap_blocks.size());
 		}
 	}
 #endif
@@ -31140,12 +31153,12 @@ void MergeSorter::MergePartition() {
 	idx_t next_entry_sizes[STANDARD_VECTOR_SIZE];
 	// Merge loop
 #ifdef DEBUG
-	auto l_count = left.Remaining();
-	auto r_count = right.Remaining();
+	auto l_count = left->Remaining();
+	auto r_count = right->Remaining();
 #endif
 	while (true) {
-		auto l_remaining = left.Remaining();
-		auto r_remaining = right.Remaining();
+		auto l_remaining = left->Remaining();
+		auto r_remaining = right->Remaining();
 		if (l_remaining + r_remaining == 0) {
 			// Done
 			break;
@@ -31158,17 +31171,12 @@ void MergeSorter::MergePartition() {
 		// Actually merge the data (radix, blob, and payload)
 		MergeRadix(next, left_smaller);
 		if (!sort_layout.all_constant) {
-			MergeData(*result->blob_sorting_data, *left.blob_sorting_data, *right.blob_sorting_data, next, left_smaller,
-			          next_entry_sizes);
-			D_ASSERT(left.block_idx == left.blob_sorting_data->block_idx &&
-			         left.entry_idx == left.blob_sorting_data->entry_idx);
-			D_ASSERT(right.block_idx == right.blob_sorting_data->block_idx &&
-			         right.entry_idx == right.blob_sorting_data->entry_idx);
+			MergeData(*result->blob_sorting_data, *left_block.blob_sorting_data, *right_block.blob_sorting_data, next,
+			          left_smaller, next_entry_sizes, true);
 			D_ASSERT(result->radix_sorting_data.size() == result->blob_sorting_data->data_blocks.size());
 		}
-		MergeData(*result->payload_data, *left.payload_data, *right.payload_data, next, left_smaller, next_entry_sizes);
-		D_ASSERT(left.block_idx == left.payload_data->block_idx && left.entry_idx == left.payload_data->entry_idx);
-		D_ASSERT(right.block_idx == right.payload_data->block_idx && right.entry_idx == right.payload_data->entry_idx);
+		MergeData(*result->payload_data, *left_block.payload_data, *right_block.payload_data, next, left_smaller,
+		          next_entry_sizes, false);
 		D_ASSERT(result->radix_sorting_data.size() == result->payload_data->data_blocks.size());
 	}
 #ifdef DEBUG
@@ -31181,34 +31189,39 @@ void MergeSorter::GetNextPartition() {
 	state.sorted_blocks_temp[state.pair_idx].push_back(make_unique<SortedBlock>(buffer_manager, state));
 	result = state.sorted_blocks_temp[state.pair_idx].back().get();
 	// Determine which blocks must be merged
-	auto &left = *state.sorted_blocks[state.pair_idx * 2];
-	auto &right = *state.sorted_blocks[state.pair_idx * 2 + 1];
-	const idx_t l_count = left.Count();
-	const idx_t r_count = right.Count();
+	auto &left_block = *state.sorted_blocks[state.pair_idx * 2];
+	auto &right_block = *state.sorted_blocks[state.pair_idx * 2 + 1];
+	const idx_t l_count = left_block.Count();
+	const idx_t r_count = right_block.Count();
+	// Initialize left and right reader
+	left = make_unique<SBScanState>(buffer_manager, state);
+	right = make_unique<SBScanState>(buffer_manager, state);
 	// Compute the work that this thread must do using Merge Path
 	idx_t l_end;
 	idx_t r_end;
 	if (state.l_start + state.r_start + state.block_capacity < l_count + r_count) {
+		left->sb = state.sorted_blocks[state.pair_idx * 2].get();
+		right->sb = state.sorted_blocks[state.pair_idx * 2 + 1].get();
 		const idx_t intersection = state.l_start + state.r_start + state.block_capacity;
-		GetIntersection(left, right, intersection, l_end, r_end);
+		GetIntersection(intersection, l_end, r_end);
 		D_ASSERT(l_end <= l_count);
 		D_ASSERT(r_end <= r_count);
 		D_ASSERT(intersection == l_end + r_end);
-		// Unpin after finding the intersection
-		if (!sort_layout.blob_layout.AllConstant()) {
-			left.blob_sorting_data->ResetIndices(0, 0);
-			right.blob_sorting_data->ResetIndices(0, 0);
-		}
 	} else {
 		l_end = l_count;
 		r_end = r_count;
 	}
 	// Create slices of the data that this thread must merge
-	left_block = left.CreateSlice(state.l_start, l_end);
-	right_block = right.CreateSlice(state.r_start, r_end);
-	// Update global state
+	left->SetIndices(0, 0);
+	right->SetIndices(0, 0);
+	left_input = left_block.CreateSlice(state.l_start, l_end, left->entry_idx);
+	right_input = right_block.CreateSlice(state.r_start, r_end, right->entry_idx);
+	left->sb = left_input.get();
+	right->sb = right_input.get();
 	state.l_start = l_end;
 	state.r_start = r_end;
+	D_ASSERT(left->Remaining() + right->Remaining() == state.block_capacity || (l_end == l_count && r_end == r_count));
+	// Update global state
 	if (state.l_start == l_count && state.r_start == r_count) {
 		// Delete references to previous pair
 		state.sorted_blocks[state.pair_idx * 2] = nullptr;
@@ -31220,9 +31233,9 @@ void MergeSorter::GetNextPartition() {
 	}
 }
 
-int MergeSorter::CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const idx_t l_idx, const idx_t r_idx) {
-	D_ASSERT(l_idx < l.Count());
-	D_ASSERT(r_idx < r.Count());
+int MergeSorter::CompareUsingGlobalIndex(SBScanState &l, SBScanState &r, const idx_t l_idx, const idx_t r_idx) {
+	D_ASSERT(l_idx < l.sb->Count());
+	D_ASSERT(r_idx < r.sb->Count());
 
 	// Easy comparison using the previous result (intersections must increase monotonically)
 	if (l_idx < state.l_start) {
@@ -31232,37 +31245,28 @@ int MergeSorter::CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const i
 		return 1;
 	}
 
-	idx_t l_block_idx;
-	idx_t l_entry_idx;
-	l.GlobalToLocalIndex(l_idx, l_block_idx, l_entry_idx);
-
-	idx_t r_block_idx;
-	idx_t r_entry_idx;
-	r.GlobalToLocalIndex(r_idx, r_block_idx, r_entry_idx);
+	l.sb->GlobalToLocalIndex(l_idx, l.block_idx, l.entry_idx);
+	r.sb->GlobalToLocalIndex(r_idx, r.block_idx, r.entry_idx);
 
-	l.PinRadix(l_block_idx);
-	r.PinRadix(r_block_idx);
-	data_ptr_t l_ptr = l.radix_handle->Ptr() + l_entry_idx * sort_layout.entry_size;
-	data_ptr_t r_ptr = r.radix_handle->Ptr() + r_entry_idx * sort_layout.entry_size;
+	l.PinRadix(l.block_idx);
+	r.PinRadix(r.block_idx);
+	data_ptr_t l_ptr = l.radix_handle->Ptr() + l.entry_idx * sort_layout.entry_size;
+	data_ptr_t r_ptr = r.radix_handle->Ptr() + r.entry_idx * sort_layout.entry_size;
 
 	int comp_res;
 	if (sort_layout.all_constant) {
 		comp_res = FastMemcmp(l_ptr, r_ptr, sort_layout.comparison_size);
 	} else {
-		l.blob_sorting_data->block_idx = l_block_idx;
-		l.blob_sorting_data->entry_idx = l_entry_idx;
-		l.blob_sorting_data->Pin();
-		r.blob_sorting_data->block_idx = r_block_idx;
-		r.blob_sorting_data->entry_idx = r_entry_idx;
-		r.blob_sorting_data->Pin();
+		l.PinData(*l.sb->blob_sorting_data);
+		r.PinData(*r.sb->blob_sorting_data);
 		comp_res = Comparators::CompareTuple(l, r, l_ptr, r_ptr, sort_layout, state.external);
 	}
 	return comp_res;
 }
 
-void MergeSorter::GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t diagonal, idx_t &l_idx, idx_t &r_idx) {
-	const idx_t l_count = l.Count();
-	const idx_t r_count = r.Count();
+void MergeSorter::GetIntersection(const idx_t diagonal, idx_t &l_idx, idx_t &r_idx) {
+	const idx_t l_count = left->sb->Count();
+	const idx_t r_count = right->sb->Count();
 	// Cover some edge cases
 	// Code coverage off because these edge cases cannot happen unless other code changes
 	// Edge cases have been tested extensively while developing Merge Path in a script
@@ -31292,16 +31296,16 @@ void MergeSorter::GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t di
 	const idx_t search_space = diagonal > MaxValue(l_count, r_count) ? l_count + r_count - diagonal
 	                                                                 : MinValue(diagonal, MinValue(l_count, r_count));
 	// Double binary search
-	idx_t left = 0;
-	idx_t right = search_space - 1;
+	idx_t li = 0;
+	idx_t ri = search_space - 1;
 	idx_t middle;
 	int comp_res;
-	while (left <= right) {
-		middle = (left + right) / 2;
+	while (li <= ri) {
+		middle = (li + ri) / 2;
 		l_idx = l_offset - middle;
 		r_idx = r_offset + middle;
 		if (l_idx == l_count || r_idx == 0) {
-			comp_res = CompareUsingGlobalIndex(l, r, l_idx - 1, r_idx);
+			comp_res = CompareUsingGlobalIndex(*left, *right, l_idx - 1, r_idx);
 			if (comp_res > 0) {
 				l_idx--;
 				r_idx++;
@@ -31318,15 +31322,15 @@ void MergeSorter::GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t di
 				break;
 			}
 		}
-		comp_res = CompareUsingGlobalIndex(l, r, l_idx, r_idx);
+		comp_res = CompareUsingGlobalIndex(*left, *right, l_idx, r_idx);
 		if (comp_res > 0) {
-			left = middle + 1;
+			li = middle + 1;
 		} else {
-			right = middle - 1;
+			ri = middle - 1;
 		}
 	}
-	int l_r_min1 = CompareUsingGlobalIndex(l, r, l_idx, r_idx - 1);
-	int l_min1_r = CompareUsingGlobalIndex(l, r, l_idx - 1, r_idx);
+	int l_r_min1 = CompareUsingGlobalIndex(*left, *right, l_idx, r_idx - 1);
+	int l_min1_r = CompareUsingGlobalIndex(*left, *right, l_idx - 1, r_idx);
 	if (l_r_min1 > 0 && l_min1_r < 0) {
 		return;
 	} else if (l_r_min1 > 0) {
@@ -31339,13 +31343,15 @@ void MergeSorter::GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t di
 }
 
 void MergeSorter::ComputeMerge(const idx_t &count, bool left_smaller[]) {
-	auto &left = *left_block;
-	auto &right = *right_block;
-	// Store indices to restore after computing the merge
-	idx_t l_block_idx = left.block_idx;
-	idx_t r_block_idx = right.block_idx;
-	idx_t l_entry_idx = left.entry_idx;
-	idx_t r_entry_idx = right.entry_idx;
+	auto &l = *left;
+	auto &r = *right;
+	auto &l_sorted_block = *l.sb;
+	auto &r_sorted_block = *r.sb;
+	// Save indices to restore afterwards
+	idx_t l_block_idx_before = l.block_idx;
+	idx_t l_entry_idx_before = l.entry_idx;
+	idx_t r_block_idx_before = r.block_idx;
+	idx_t r_entry_idx_before = r.entry_idx;
 	// Data pointers for both sides
 	data_ptr_t l_radix_ptr;
 	data_ptr_t r_radix_ptr;
@@ -31353,91 +31359,84 @@ void MergeSorter::ComputeMerge(const idx_t &count, bool left_smaller[]) {
 	idx_t compared = 0;
 	while (compared < count) {
 		// Move to the next block (if needed)
-		if (l_block_idx < left.radix_sorting_data.size() && l_entry_idx == left.radix_sorting_data[l_block_idx].count) {
-			l_block_idx++;
-			l_entry_idx = 0;
-			if (!sort_layout.all_constant) {
-				left.blob_sorting_data->block_idx = l_block_idx;
-				left.blob_sorting_data->entry_idx = l_entry_idx;
-			}
-		}
-		if (r_block_idx < right.radix_sorting_data.size() &&
-		    r_entry_idx == right.radix_sorting_data[r_block_idx].count) {
-			r_block_idx++;
-			r_entry_idx = 0;
-			if (!sort_layout.all_constant) {
-				right.blob_sorting_data->block_idx = r_block_idx;
-				right.blob_sorting_data->entry_idx = r_entry_idx;
-			}
-		}
-		const bool l_done = l_block_idx == left.radix_sorting_data.size();
-		const bool r_done = r_block_idx == right.radix_sorting_data.size();
+		if (l.block_idx < l_sorted_block.radix_sorting_data.size() &&
+		    l.entry_idx == l_sorted_block.radix_sorting_data[l.block_idx].count) {
+			l.block_idx++;
+			l.entry_idx = 0;
+		}
+		if (r.block_idx < r_sorted_block.radix_sorting_data.size() &&
+		    r.entry_idx == r_sorted_block.radix_sorting_data[r.block_idx].count) {
+			r.block_idx++;
+			r.entry_idx = 0;
+		}
+		const bool l_done = l.block_idx == l_sorted_block.radix_sorting_data.size();
+		const bool r_done = r.block_idx == r_sorted_block.radix_sorting_data.size();
 		if (l_done || r_done) {
 			// One of the sides is exhausted, no need to compare
 			break;
 		}
 		// Pin the radix sorting data
 		if (!l_done) {
-			left.PinRadix(l_block_idx);
-			l_radix_ptr = left.radix_handle->Ptr() + l_entry_idx * sort_layout.entry_size;
+			left->PinRadix(l.block_idx);
+			l_radix_ptr = left->RadixPtr();
 		}
 		if (!r_done) {
-			right.PinRadix(r_block_idx);
-			r_radix_ptr = right.radix_handle->Ptr() + r_entry_idx * sort_layout.entry_size;
+			right->PinRadix(r.block_idx);
+			r_radix_ptr = right->RadixPtr();
 		}
-		const idx_t &l_count = !l_done ? left.radix_sorting_data[l_block_idx].count : 0;
-		const idx_t &r_count = !r_done ? right.radix_sorting_data[r_block_idx].count : 0;
+		const idx_t &l_count = !l_done ? l_sorted_block.radix_sorting_data[l.block_idx].count : 0;
+		const idx_t &r_count = !r_done ? r_sorted_block.radix_sorting_data[r.block_idx].count : 0;
 		// Compute the merge
 		if (sort_layout.all_constant) {
 			// All sorting columns are constant size
-			for (; compared < count && l_entry_idx < l_count && r_entry_idx < r_count; compared++) {
+			for (; compared < count && l.entry_idx < l_count && r.entry_idx < r_count; compared++) {
 				left_smaller[compared] = FastMemcmp(l_radix_ptr, r_radix_ptr, sort_layout.comparison_size) < 0;
 				const bool &l_smaller = left_smaller[compared];
 				const bool r_smaller = !l_smaller;
 				// Use comparison bool (0 or 1) to increment entries and pointers
-				l_entry_idx += l_smaller;
-				r_entry_idx += r_smaller;
+				l.entry_idx += l_smaller;
+				r.entry_idx += r_smaller;
 				l_radix_ptr += l_smaller * sort_layout.entry_size;
 				r_radix_ptr += r_smaller * sort_layout.entry_size;
 			}
 		} else {
 			// Pin the blob data
 			if (!l_done) {
-				left.blob_sorting_data->Pin();
+				left->PinData(*l_sorted_block.blob_sorting_data);
 			}
 			if (!r_done) {
-				right.blob_sorting_data->Pin();
+				right->PinData(*r_sorted_block.blob_sorting_data);
 			}
 			// Merge with variable size sorting columns
-			for (; compared < count && l_entry_idx < l_count && r_entry_idx < r_count; compared++) {
-				D_ASSERT(l_block_idx == left.blob_sorting_data->block_idx &&
-				         l_entry_idx == left.blob_sorting_data->entry_idx);
-				D_ASSERT(r_block_idx == right.blob_sorting_data->block_idx &&
-				         r_entry_idx == right.blob_sorting_data->entry_idx);
+			for (; compared < count && l.entry_idx < l_count && r.entry_idx < r_count; compared++) {
 				left_smaller[compared] =
-				    Comparators::CompareTuple(left, right, l_radix_ptr, r_radix_ptr, sort_layout, state.external) < 0;
+				    Comparators::CompareTuple(*left, *right, l_radix_ptr, r_radix_ptr, sort_layout, state.external) < 0;
 				const bool &l_smaller = left_smaller[compared];
 				const bool r_smaller = !l_smaller;
 				// Use comparison bool (0 or 1) to increment entries and pointers
-				l_entry_idx += l_smaller;
-				r_entry_idx += r_smaller;
+				l.entry_idx += l_smaller;
+				r.entry_idx += r_smaller;
 				l_radix_ptr += l_smaller * sort_layout.entry_size;
 				r_radix_ptr += r_smaller * sort_layout.entry_size;
-				left.blob_sorting_data->Advance(l_smaller);
-				right.blob_sorting_data->Advance(r_smaller);
 			}
 		}
 	}
-	// Reset block indices before the actual merge
-	if (!sort_layout.all_constant) {
-		left.blob_sorting_data->ResetIndices(left.block_idx, left.entry_idx);
-		right.blob_sorting_data->ResetIndices(right.block_idx, right.entry_idx);
-	}
+	// Reset block indices
+	left->SetIndices(l_block_idx_before, l_entry_idx_before);
+	right->SetIndices(r_block_idx_before, r_entry_idx_before);
 }
 
 void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
-	auto &left = *left_block;
-	auto &right = *right_block;
+	auto &l = *left;
+	auto &r = *right;
+	// Save indices to restore afterwards
+	idx_t l_block_idx_before = l.block_idx;
+	idx_t l_entry_idx_before = l.entry_idx;
+	idx_t r_block_idx_before = r.block_idx;
+	idx_t r_entry_idx_before = r.entry_idx;
+
+	auto &l_blocks = l.sb->radix_sorting_data;
+	auto &r_blocks = r.sb->radix_sorting_data;
 	RowDataBlock *l_block;
 	RowDataBlock *r_block;
 
@@ -31451,54 +31450,63 @@ void MergeSorter::MergeRadix(const idx_t &count, const bool left_smaller[]) {
 	idx_t copied = 0;
 	while (copied < count) {
 		// Move to the next block (if needed)
-		if (left.block_idx < left.radix_sorting_data.size() &&
-		    left.entry_idx == left.radix_sorting_data[left.block_idx].count) {
+		if (l.block_idx < l_blocks.size() && l.entry_idx == l_blocks[l.block_idx].count) {
 			// Delete reference to previous block
-			left.radix_sorting_data[left.block_idx].block = nullptr;
+			l_blocks[l.block_idx].block = nullptr;
 			// Advance block
-			left.block_idx++;
-			left.entry_idx = 0;
+			l.block_idx++;
+			l.entry_idx = 0;
 		}
-		if (right.block_idx < right.radix_sorting_data.size() &&
-		    right.entry_idx == right.radix_sorting_data[right.block_idx].count) {
+		if (r.block_idx < r_blocks.size() && r.entry_idx == r_blocks[r.block_idx].count) {
 			// Delete reference to previous block
-			right.radix_sorting_data[right.block_idx].block = nullptr;
+			r_blocks[r.block_idx].block = nullptr;
 			// Advance block
-			right.block_idx++;
-			right.entry_idx = 0;
+			r.block_idx++;
+			r.entry_idx = 0;
 		}
-		const bool l_done = left.block_idx == left.radix_sorting_data.size();
-		const bool r_done = right.block_idx == right.radix_sorting_data.size();
+		const bool l_done = l.block_idx == l_blocks.size();
+		const bool r_done = r.block_idx == r_blocks.size();
 		// Pin the radix sortable blocks
 		if (!l_done) {
-			l_block = &left.radix_sorting_data[left.block_idx];
-			left.PinRadix(left.block_idx);
-			l_ptr = left.radix_handle->Ptr() + left.entry_idx * sort_layout.entry_size;
+			l_block = &l_blocks[l.block_idx];
+			left->PinRadix(l.block_idx);
+			l_ptr = l.RadixPtr();
 		}
 		if (!r_done) {
-			r_block = &right.radix_sorting_data[right.block_idx];
-			right.PinRadix(right.block_idx);
-			r_ptr = right.radix_handle->Ptr() + right.entry_idx * sort_layout.entry_size;
+			r_block = &r_blocks[r.block_idx];
+			r.PinRadix(r.block_idx);
+			r_ptr = r.RadixPtr();
 		}
 		const idx_t &l_count = !l_done ? l_block->count : 0;
 		const idx_t &r_count = !r_done ? r_block->count : 0;
 		// Copy using computed merge
 		if (!l_done && !r_done) {
 			// Both sides have data - merge
-			MergeRows(l_ptr, left.entry_idx, l_count, r_ptr, right.entry_idx, r_count, result_block, result_ptr,
+			MergeRows(l_ptr, l.entry_idx, l_count, r_ptr, r.entry_idx, r_count, result_block, result_ptr,
 			          sort_layout.entry_size, left_smaller, copied, count);
 		} else if (r_done) {
 			// Right side is exhausted
-			FlushRows(l_ptr, left.entry_idx, l_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
+			FlushRows(l_ptr, l.entry_idx, l_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
 		} else {
 			// Left side is exhausted
-			FlushRows(r_ptr, right.entry_idx, r_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
+			FlushRows(r_ptr, r.entry_idx, r_count, result_block, result_ptr, sort_layout.entry_size, copied, count);
 		}
 	}
+	// Reset block indices
+	left->SetIndices(l_block_idx_before, l_entry_idx_before);
+	right->SetIndices(r_block_idx_before, r_entry_idx_before);
 }
 
 void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
-                            const bool left_smaller[], idx_t next_entry_sizes[]) {
+                            const bool left_smaller[], idx_t next_entry_sizes[], bool reset_indices) {
+	auto &l = *left;
+	auto &r = *right;
+	// Save indices to restore afterwards
+	idx_t l_block_idx_before = l.block_idx;
+	idx_t l_entry_idx_before = l.entry_idx;
+	idx_t r_block_idx_before = r.block_idx;
+	idx_t r_entry_idx_before = r.entry_idx;
+
 	const auto &layout = result_data.layout;
 	const idx_t row_width = layout.GetRowWidth();
 	const idx_t heap_pointer_offset = layout.GetHeapPointerOffset();
@@ -31527,76 +31535,70 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 	idx_t copied = 0;
 	while (copied < count) {
 		// Move to new data blocks (if needed)
-		if (l_data.block_idx < l_data.data_blocks.size() &&
-		    l_data.entry_idx == l_data.data_blocks[l_data.block_idx].count) {
+		if (l.block_idx < l_data.data_blocks.size() && l.entry_idx == l_data.data_blocks[l.block_idx].count) {
 			// Delete reference to previous block
-			l_data.data_blocks[l_data.block_idx].block = nullptr;
+			l_data.data_blocks[l.block_idx].block = nullptr;
 			if (!layout.AllConstant() && state.external) {
-				l_data.heap_blocks[l_data.block_idx].block = nullptr;
+				l_data.heap_blocks[l.block_idx].block = nullptr;
 			}
 			// Advance block
-			l_data.block_idx++;
-			l_data.entry_idx = 0;
+			l.block_idx++;
+			l.entry_idx = 0;
 		}
-		if (r_data.block_idx < r_data.data_blocks.size() &&
-		    r_data.entry_idx == r_data.data_blocks[r_data.block_idx].count) {
+		if (r.block_idx < r_data.data_blocks.size() && r.entry_idx == r_data.data_blocks[r.block_idx].count) {
 			// Delete reference to previous block
-			r_data.data_blocks[r_data.block_idx].block = nullptr;
+			r_data.data_blocks[r.block_idx].block = nullptr;
 			if (!layout.AllConstant() && state.external) {
-				r_data.heap_blocks[r_data.block_idx].block = nullptr;
+				r_data.heap_blocks[r.block_idx].block = nullptr;
 			}
 			// Advance block
-			r_data.block_idx++;
-			r_data.entry_idx = 0;
+			r.block_idx++;
+			r.entry_idx = 0;
 		}
-		const bool l_done = l_data.block_idx == l_data.data_blocks.size();
-		const bool r_done = r_data.block_idx == r_data.data_blocks.size();
+		const bool l_done = l.block_idx == l_data.data_blocks.size();
+		const bool r_done = r.block_idx == r_data.data_blocks.size();
 		// Pin the row data blocks
 		if (!l_done) {
-			l_data.Pin();
-			l_ptr = l_data.data_handle->Ptr() + l_data.entry_idx * row_width;
+			l.PinData(l_data);
+			l_ptr = l.DataPtr(l_data);
 		}
 		if (!r_done) {
-			r_data.Pin();
-			r_ptr = r_data.data_handle->Ptr() + r_data.entry_idx * row_width;
+			r.PinData(r_data);
+			r_ptr = r.DataPtr(r_data);
 		}
-		const idx_t &l_count = !l_done ? l_data.data_blocks[l_data.block_idx].count : 0;
-		const idx_t &r_count = !r_done ? r_data.data_blocks[r_data.block_idx].count : 0;
+		const idx_t &l_count = !l_done ? l_data.data_blocks[l.block_idx].count : 0;
+		const idx_t &r_count = !r_done ? r_data.data_blocks[r.block_idx].count : 0;
 		// Perform the merge
 		if (layout.AllConstant() || !state.external) {
 			// If all constant size, or if we are doing an in-memory sort, we do not need to touch the heap
 			if (!l_done && !r_done) {
 				// Both sides have data - merge
-				MergeRows(l_ptr, l_data.entry_idx, l_count, r_ptr, r_data.entry_idx, r_count, result_data_block,
-				          result_data_ptr, row_width, left_smaller, copied, count);
+				MergeRows(l_ptr, l.entry_idx, l_count, r_ptr, r.entry_idx, r_count, result_data_block, result_data_ptr,
+				          row_width, left_smaller, copied, count);
 			} else if (r_done) {
 				// Right side is exhausted
-				FlushRows(l_ptr, l_data.entry_idx, l_count, result_data_block, result_data_ptr, row_width, copied,
-				          count);
+				FlushRows(l_ptr, l.entry_idx, l_count, result_data_block, result_data_ptr, row_width, copied, count);
 			} else {
 				// Left side is exhausted
-				FlushRows(r_ptr, r_data.entry_idx, r_count, result_data_block, result_data_ptr, row_width, copied,
-				          count);
+				FlushRows(r_ptr, r.entry_idx, r_count, result_data_block, result_data_ptr, row_width, copied, count);
 			}
 		} else {
 			// External sorting with variable size data. Pin the heap blocks too
 			if (!l_done) {
-				l_heap_ptr = l_data.heap_handle->Ptr() + Load<idx_t>(l_ptr + heap_pointer_offset);
-				D_ASSERT(l_heap_ptr - l_data.heap_handle->Ptr() >= 0);
-				D_ASSERT((idx_t)(l_heap_ptr - l_data.heap_handle->Ptr()) <
-				         l_data.heap_blocks[l_data.block_idx].byte_offset);
+				l_heap_ptr = l.BaseHeapPtr(l_data) + Load<idx_t>(l_ptr + heap_pointer_offset);
+				D_ASSERT(l_heap_ptr - l.BaseHeapPtr(l_data) >= 0);
+				D_ASSERT((idx_t)(l_heap_ptr - l.BaseHeapPtr(l_data)) < l_data.heap_blocks[l.block_idx].byte_offset);
 			}
 			if (!r_done) {
-				r_heap_ptr = r_data.heap_handle->Ptr() + Load<idx_t>(r_ptr + heap_pointer_offset);
-				D_ASSERT(r_heap_ptr - r_data.heap_handle->Ptr() >= 0);
-				D_ASSERT((idx_t)(r_heap_ptr - r_data.heap_handle->Ptr()) <
-				         r_data.heap_blocks[r_data.block_idx].byte_offset);
+				r_heap_ptr = r.BaseHeapPtr(r_data) + Load<idx_t>(r_ptr + heap_pointer_offset);
+				D_ASSERT(r_heap_ptr - r.BaseHeapPtr(r_data) >= 0);
+				D_ASSERT((idx_t)(r_heap_ptr - r.BaseHeapPtr(r_data)) < r_data.heap_blocks[r.block_idx].byte_offset);
 			}
 			// Both the row and heap data need to be dealt with
 			if (!l_done && !r_done) {
 				// Both sides have data - merge
-				idx_t l_idx_copy = l_data.entry_idx;
-				idx_t r_idx_copy = r_data.entry_idx;
+				idx_t l_idx_copy = l.entry_idx;
+				idx_t r_idx_copy = r.entry_idx;
 				data_ptr_t result_data_ptr_copy = result_data_ptr;
 				idx_t copied_copy = copied;
 				// Merge row data
@@ -31618,10 +31620,10 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 					entry_size =
 					    l_smaller * Load<uint32_t>(l_heap_ptr_copy) + r_smaller * Load<uint32_t>(r_heap_ptr_copy);
 					D_ASSERT(entry_size >= sizeof(uint32_t));
-					D_ASSERT(l_heap_ptr_copy - l_data.heap_handle->Ptr() + l_smaller * entry_size <=
-					         l_data.heap_blocks[l_data.block_idx].byte_offset);
-					D_ASSERT(r_heap_ptr_copy - r_data.heap_handle->Ptr() + r_smaller * entry_size <=
-					         r_data.heap_blocks[r_data.block_idx].byte_offset);
+					D_ASSERT(l_heap_ptr_copy - l.BaseHeapPtr(l_data) + l_smaller * entry_size <=
+					         l_data.heap_blocks[l.block_idx].byte_offset);
+					D_ASSERT(r_heap_ptr_copy - r.BaseHeapPtr(r_data) + r_smaller * entry_size <=
+					         r_data.heap_blocks[r.block_idx].byte_offset);
 					l_heap_ptr_copy += l_smaller * entry_size;
 					r_heap_ptr_copy += r_smaller * entry_size;
 					copy_bytes += entry_size;
@@ -31645,8 +31647,8 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 					result_heap_ptr += entry_size;
 					l_heap_ptr += l_smaller * entry_size;
 					r_heap_ptr += r_smaller * entry_size;
-					l_data.entry_idx += l_smaller;
-					r_data.entry_idx += r_smaller;
+					l.entry_idx += l_smaller;
+					r.entry_idx += r_smaller;
 				}
 				// Update result indices and pointers
 				result_heap_block->count += merged;
@@ -31654,16 +31656,20 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 				copied += merged;
 			} else if (r_done) {
 				// Right side is exhausted - flush left
-				FlushBlobs(layout, l_count, l_ptr, l_data.entry_idx, l_heap_ptr, result_data_block, result_data_ptr,
+				FlushBlobs(layout, l_count, l_ptr, l.entry_idx, l_heap_ptr, result_data_block, result_data_ptr,
 				           result_heap_block, *result_heap_handle, result_heap_ptr, copied, count);
 			} else {
 				// Left side is exhausted - flush right
-				FlushBlobs(layout, r_count, r_ptr, r_data.entry_idx, r_heap_ptr, result_data_block, result_data_ptr,
+				FlushBlobs(layout, r_count, r_ptr, r.entry_idx, r_heap_ptr, result_data_block, result_data_ptr,
 				           result_heap_block, *result_heap_handle, result_heap_ptr, copied, count);
 			}
 			D_ASSERT(result_data_block->count == result_heap_block->count);
 		}
 	}
+	if (reset_indices) {
+		left->SetIndices(l_block_idx_before, l_entry_idx_before);
+		right->SetIndices(r_block_idx_before, r_entry_idx_before);
+	}
 }
 
 void MergeSorter::MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr,
@@ -32638,8 +32644,9 @@ void GlobalSortState::CompleteMergeRound() {
 
 namespace duckdb {
 
-SortedData::SortedData(const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state)
-    : layout(layout), block_idx(0), entry_idx(0), swizzled(false), buffer_manager(buffer_manager), state(state) {
+SortedData::SortedData(SortedDataType type, const RowLayout &layout, BufferManager &buffer_manager,
+                       GlobalSortState &state)
+    : type(type), layout(layout), swizzled(false), buffer_manager(buffer_manager), state(state) {
 }
 
 idx_t SortedData::Count() {
@@ -32652,37 +32659,6 @@ idx_t SortedData::Count() {
 	return count;
 }
 
-void SortedData::Pin() {
-	PinData();
-	if (!layout.AllConstant() && state.external) {
-		PinHeap();
-	}
-}
-
-data_ptr_t SortedData::DataPtr() const {
-	D_ASSERT(data_blocks[block_idx].block->Readers() != 0 &&
-	         data_handle->handle->BlockId() == data_blocks[block_idx].block->BlockId());
-	return data_ptr + entry_idx * layout.GetRowWidth();
-}
-
-data_ptr_t SortedData::HeapPtr() const {
-	D_ASSERT(!layout.AllConstant() && state.external);
-	D_ASSERT(heap_blocks[block_idx].block->Readers() != 0 &&
-	         heap_handle->handle->BlockId() == heap_blocks[block_idx].block->BlockId());
-	return heap_ptr + Load<idx_t>(DataPtr() + layout.GetHeapPointerOffset());
-}
-
-void SortedData::Advance(const bool &adv) {
-	entry_idx += adv;
-	if (entry_idx == data_blocks[block_idx].count) {
-		block_idx++;
-		entry_idx = 0;
-		if (block_idx < data_blocks.size()) {
-			Pin();
-		}
-	}
-}
-
 void SortedData::CreateBlock() {
 	auto capacity =
 	    MaxValue(((idx_t)Storage::BLOCK_SIZE + layout.GetRowWidth() - 1) / layout.GetRowWidth(), state.block_capacity);
@@ -32693,15 +32669,9 @@ void SortedData::CreateBlock() {
 	}
 }
 
-void SortedData::ResetIndices(idx_t block_idx_to, idx_t entry_idx_to) {
-	block_idx = block_idx_to;
-	entry_idx = entry_idx_to;
-}
-
-unique_ptr<SortedData> SortedData::CreateSlice(idx_t start_block_index, idx_t start_entry_index, idx_t end_block_index,
-                                               idx_t end_entry_index) {
+unique_ptr<SortedData> SortedData::CreateSlice(idx_t start_block_index, idx_t end_block_index, idx_t end_entry_index) {
 	// Add the corresponding blocks to the result
-	auto result = make_unique<SortedData>(layout, buffer_manager, state);
+	auto result = make_unique<SortedData>(type, layout, buffer_manager, state);
 	for (idx_t i = start_block_index; i <= end_block_index; i++) {
 		result->data_blocks.push_back(data_blocks[i]);
 		if (!layout.AllConstant() && state.external) {
@@ -32716,7 +32686,6 @@ unique_ptr<SortedData> SortedData::CreateSlice(idx_t start_block_index, idx_t st
 		}
 	}
 	// Use start and end entry indices to set the boundaries
-	result->entry_idx = start_entry_index;
 	D_ASSERT(end_entry_index <= result->data_blocks.back().count);
 	result->data_blocks.back().count = end_entry_index;
 	if (!layout.AllConstant() && state.external) {
@@ -32742,29 +32711,11 @@ void SortedData::Unswizzle() {
 	heap_blocks.clear();
 }
 
-void SortedData::PinData() {
-	D_ASSERT(block_idx < data_blocks.size());
-	auto &block = data_blocks[block_idx];
-	if (!data_handle || data_handle->handle->BlockId() != block.block->BlockId()) {
-		data_handle = buffer_manager.Pin(data_blocks[block_idx].block);
-	}
-	data_ptr = data_handle->Ptr();
-}
-
-void SortedData::PinHeap() {
-	D_ASSERT(!layout.AllConstant() && state.external);
-	auto &block = heap_blocks[block_idx];
-	if (!heap_handle || heap_handle->handle->BlockId() != block.block->BlockId()) {
-		heap_handle = buffer_manager.Pin(heap_blocks[block_idx].block);
-	}
-	heap_ptr = heap_handle->Ptr();
-}
-
 SortedBlock::SortedBlock(BufferManager &buffer_manager, GlobalSortState &state)
-    : block_idx(0), entry_idx(0), buffer_manager(buffer_manager), state(state), sort_layout(state.sort_layout),
+    : buffer_manager(buffer_manager), state(state), sort_layout(state.sort_layout),
       payload_layout(state.payload_layout) {
-	blob_sorting_data = make_unique<SortedData>(sort_layout.blob_layout, buffer_manager, state);
-	payload_data = make_unique<SortedData>(payload_layout, buffer_manager, state);
+	blob_sorting_data = make_unique<SortedData>(SortedDataType::BLOB, sort_layout.blob_layout, buffer_manager, state);
+	payload_data = make_unique<SortedData>(SortedDataType::PAYLOAD, payload_layout, buffer_manager, state);
 }
 
 idx_t SortedBlock::Count() const {
@@ -32777,17 +32728,6 @@ idx_t SortedBlock::Count() const {
 	return count;
 }
 
-idx_t SortedBlock::Remaining() const {
-	idx_t remaining = 0;
-	if (block_idx < radix_sorting_data.size()) {
-		remaining += radix_sorting_data[block_idx].count - entry_idx;
-		for (idx_t i = block_idx + 1; i < radix_sorting_data.size(); i++) {
-			remaining += radix_sorting_data[i].count;
-		}
-	}
-	return remaining;
-}
-
 void SortedBlock::InitializeWrite() {
 	CreateBlock();
 	if (!sort_layout.all_constant) {
@@ -32802,14 +32742,6 @@ void SortedBlock::CreateBlock() {
 	radix_sorting_data.emplace_back(buffer_manager, capacity, sort_layout.entry_size);
 }
 
-void SortedBlock::PinRadix(idx_t pin_block_idx) {
-	D_ASSERT(pin_block_idx < radix_sorting_data.size());
-	auto &block = radix_sorting_data[pin_block_idx];
-	if (!radix_handle || radix_handle->handle->BlockId() != block.block->BlockId()) {
-		radix_handle = buffer_manager.Pin(block.block);
-	}
-}
-
 void SortedBlock::AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks) {
 	D_ASSERT(Count() == 0);
 	for (auto &sb : sorted_blocks) {
@@ -32854,7 +32786,7 @@ void SortedBlock::GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block
 	D_ASSERT(local_entry_index < radix_sorting_data[local_block_index].count);
 }
 
-unique_ptr<SortedBlock> SortedBlock::CreateSlice(const idx_t start, const idx_t end) {
+unique_ptr<SortedBlock> SortedBlock::CreateSlice(const idx_t start, const idx_t end, idx_t &entry_idx) {
 	// Identify blocks/entry indices of this slice
 	idx_t start_block_index;
 	idx_t start_entry_index;
@@ -32872,18 +32804,15 @@ unique_ptr<SortedBlock> SortedBlock::CreateSlice(const idx_t start, const idx_t
 		radix_sorting_data[i].block = nullptr;
 	}
 	// Use start and end entry indices to set the boundaries
-	result->entry_idx = start_entry_index;
+	entry_idx = start_entry_index;
 	D_ASSERT(end_entry_index <= result->radix_sorting_data.back().count);
 	result->radix_sorting_data.back().count = end_entry_index;
 	// Same for the var size sorting data
 	if (!sort_layout.all_constant) {
-		result->blob_sorting_data =
-		    blob_sorting_data->CreateSlice(start_block_index, start_entry_index, end_block_index, end_entry_index);
+		result->blob_sorting_data = blob_sorting_data->CreateSlice(start_block_index, end_block_index, end_entry_index);
 	}
 	// And the payload data
-	result->payload_data =
-	    payload_data->CreateSlice(start_block_index, start_entry_index, end_block_index, end_entry_index);
-	D_ASSERT(result->Remaining() == end - start);
+	result->payload_data = payload_data->CreateSlice(start_block_index, end_block_index, end_entry_index);
 	return result;
 }
 
@@ -32918,19 +32847,90 @@ idx_t SortedBlock::SizeInBytes() const {
 	return bytes;
 }
 
-SortedDataScanner::SortedDataScanner(SortedData &sorted_data, GlobalSortState &global_sort_state)
-    : sorted_data(sorted_data), total_count(sorted_data.Count()), global_sort_state(global_sort_state),
-      total_scanned(0) {
+SBScanState::SBScanState(BufferManager &buffer_manager, GlobalSortState &state)
+    : buffer_manager(buffer_manager), sort_layout(state.sort_layout), state(state), block_idx(0), entry_idx(0) {
+}
+
+void SBScanState::PinRadix(idx_t block_idx_to) {
+	auto &radix_sorting_data = sb->radix_sorting_data;
+	D_ASSERT(block_idx_to < radix_sorting_data.size());
+	auto &block = radix_sorting_data[block_idx_to];
+	if (!radix_handle || radix_handle->handle->BlockId() != block.block->BlockId()) {
+		radix_handle = buffer_manager.Pin(block.block);
+	}
+}
+
+void SBScanState::PinData(SortedData &sd) {
+	D_ASSERT(block_idx < sd.data_blocks.size());
+	auto &data_handle = sd.type == SortedDataType::BLOB ? blob_sorting_data_handle : payload_data_handle;
+	auto &heap_handle = sd.type == SortedDataType::BLOB ? blob_sorting_heap_handle : payload_heap_handle;
+
+	auto &data_block = sd.data_blocks[block_idx];
+	if (!data_handle || data_handle->handle->BlockId() != data_block.block->BlockId()) {
+		data_handle = buffer_manager.Pin(data_block.block);
+	}
+	if (sd.layout.AllConstant() || !state.external) {
+		return;
+	}
+	auto &heap_block = sd.heap_blocks[block_idx];
+	if (!heap_handle || heap_handle->handle->BlockId() != heap_block.block->BlockId()) {
+		heap_handle = buffer_manager.Pin(heap_block.block);
+	}
+}
+
+data_ptr_t SBScanState::RadixPtr() const {
+	return radix_handle->Ptr() + entry_idx * sort_layout.entry_size;
+}
+
+data_ptr_t SBScanState::DataPtr(SortedData &sd) const {
+	auto &data_handle = sd.type == SortedDataType::BLOB ? *blob_sorting_data_handle : *payload_data_handle;
+	D_ASSERT(sd.data_blocks[block_idx].block->Readers() != 0 &&
+	         data_handle.handle->BlockId() == sd.data_blocks[block_idx].block->BlockId());
+	return data_handle.Ptr() + entry_idx * sd.layout.GetRowWidth();
+}
+
+data_ptr_t SBScanState::HeapPtr(SortedData &sd) const {
+	return BaseHeapPtr(sd) + Load<idx_t>(DataPtr(sd) + sd.layout.GetHeapPointerOffset());
 }
 
-void SortedDataScanner::Scan(DataChunk &chunk) {
+data_ptr_t SBScanState::BaseHeapPtr(SortedData &sd) const {
+	auto &heap_handle = sd.type == SortedDataType::BLOB ? *blob_sorting_heap_handle : *payload_heap_handle;
+	D_ASSERT(!sd.layout.AllConstant() && state.external);
+	D_ASSERT(sd.heap_blocks[block_idx].block->Readers() != 0 &&
+	         heap_handle.handle->BlockId() == sd.heap_blocks[block_idx].block->BlockId());
+	return heap_handle.Ptr();
+}
+
+idx_t SBScanState::Remaining() const {
+	const auto &blocks = sb->radix_sorting_data;
+	idx_t remaining = 0;
+	if (block_idx < blocks.size()) {
+		remaining += blocks[block_idx].count - entry_idx;
+		for (idx_t i = block_idx + 1; i < blocks.size(); i++) {
+			remaining += blocks[i].count;
+		}
+	}
+	return remaining;
+}
+
+void SBScanState::SetIndices(idx_t block_idx_to, idx_t entry_idx_to) {
+	block_idx = block_idx_to;
+	entry_idx = entry_idx_to;
+}
+
+PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_sort_state)
+    : sorted_data(sorted_data), read_state(global_sort_state.buffer_manager, global_sort_state),
+      total_count(sorted_data.Count()), global_sort_state(global_sort_state), total_scanned(0) {
+}
+
+void PayloadScanner::Scan(DataChunk &chunk) {
 	auto count = MinValue((idx_t)STANDARD_VECTOR_SIZE, total_count - total_scanned);
 	if (count == 0) {
-		D_ASSERT(sorted_data.block_idx == sorted_data.data_blocks.size());
+		D_ASSERT(read_state.block_idx == sorted_data.data_blocks.size());
 		return;
 	}
 	// Eagerly delete references to blocks that we've passed
-	for (idx_t i = 0; i < sorted_data.block_idx; i++) {
+	for (idx_t i = 0; i < read_state.block_idx; i++) {
 		sorted_data.data_blocks[i].block = nullptr;
 	}
 	const idx_t &row_width = sorted_data.layout.GetRowWidth();
@@ -32938,10 +32938,10 @@ void SortedDataScanner::Scan(DataChunk &chunk) {
 	idx_t scanned = 0;
 	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
 	while (scanned < count) {
-		sorted_data.Pin();
-		auto &data_block = sorted_data.data_blocks[sorted_data.block_idx];
-		idx_t next = MinValue(data_block.count - sorted_data.entry_idx, count - scanned);
-		const data_ptr_t data_ptr = sorted_data.data_handle->Ptr() + sorted_data.entry_idx * row_width;
+		read_state.PinData(sorted_data);
+		auto &data_block = sorted_data.data_blocks[read_state.block_idx];
+		idx_t next = MinValue(data_block.count - read_state.entry_idx, count - scanned);
+		const data_ptr_t data_ptr = read_state.payload_data_handle->Ptr() + read_state.entry_idx * row_width;
 		// Set up the next pointers
 		data_ptr_t row_ptr = data_ptr;
 		for (idx_t i = 0; i < next; i++) {
@@ -32950,14 +32950,15 @@ void SortedDataScanner::Scan(DataChunk &chunk) {
 		}
 		// Unswizzle the offsets back to pointers (if needed)
 		if (!sorted_data.layout.AllConstant() && global_sort_state.external) {
-			RowOperations::UnswizzleHeapPointer(sorted_data.layout, data_ptr, sorted_data.heap_handle->Ptr(), next);
+			RowOperations::UnswizzleHeapPointer(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(),
+			                                    next);
 			RowOperations::UnswizzleColumns(sorted_data.layout, data_ptr, next);
 		}
 		// Update state indices
-		sorted_data.entry_idx += next;
-		if (sorted_data.entry_idx == data_block.count) {
-			sorted_data.block_idx++;
-			sorted_data.entry_idx = 0;
+		read_state.entry_idx += next;
+		if (read_state.entry_idx == data_block.count) {
+			read_state.block_idx++;
+			read_state.entry_idx = 0;
 		}
 		scanned += next;
 	}
@@ -56551,7 +56552,7 @@ static void ScanSortedPartition(WindowOperatorState &state, ChunkCollection &inp
 	payload_types.insert(payload_types.end(), over_types.begin(), over_types.end());
 
 	// scan the sorted row data
-	SortedDataScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
+	PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
 	for (;;) {
 		DataChunk payload_chunk;
 		payload_chunk.Initialize(payload_types);
@@ -62364,7 +62365,7 @@ void PhysicalOrder::ScheduleMergeTasks(Pipeline &pipeline, Event &event, OrderGl
 class PhysicalOrderOperatorState : public GlobalSourceState {
 public:
 	//! Payload scanner
-	unique_ptr<SortedDataScanner> scanner;
+	unique_ptr<PayloadScanner> scanner;
 };
 
 unique_ptr<GlobalSourceState> PhysicalOrder::GetGlobalSourceState(ClientContext &context) const {
@@ -62383,7 +62384,7 @@ void PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 			return;
 		}
 		state.scanner =
-		    make_unique<SortedDataScanner>(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
+		    make_unique<PayloadScanner>(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
 	}
 
 	// Scan the next data chunk
@@ -62483,7 +62484,7 @@ PhysicalTopN::PhysicalTopN(vector<LogicalType> types, vector<BoundOrderByNode> o
 class TopNHeap;
 
 struct TopNScanState {
-	unique_ptr<SortedDataScanner> scanner;
+	unique_ptr<PayloadScanner> scanner;
 	idx_t pos;
 	bool exclude_offset;
 };
@@ -62613,7 +62614,7 @@ void TopNSortState::InitializeScan(TopNScanState &state, bool exclude_offset) {
 		state.scanner = nullptr;
 	} else {
 		D_ASSERT(global_state->sorted_blocks.size() == 1);
-		state.scanner = make_unique<SortedDataScanner>(*global_state->sorted_blocks[0]->payload_data, *global_state);
+		state.scanner = make_unique<PayloadScanner>(*global_state->sorted_blocks[0]->payload_data, *global_state);
 	}
 	state.pos = 0;
 	state.exclude_offset = exclude_offset && heap.offset > 0;
@@ -80621,6 +80622,11 @@ struct RLEFun {
 	static bool TypeIsSupported(PhysicalType type);
 };
 
+struct BitpackingFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
 } // namespace duckdb
 
 
@@ -80640,6 +80646,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 +80695,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 +159290,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/
+*/
 
 
-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) {
+// 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://fastpforlib.me/en/
+ */
+
+#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 +160700,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 +209308,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 +260734,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.
+
 */